ISTQB Advanced (CTAL-AT v2.0) Mock Exam #3 — Questions & Answers

Every test type is deferred to the period after the iteration, because results obtained against stubs of the legacy core carry no information about the delivered increment and would have to be repeated once the core is rebuilt.

Only white-box testing stays inside the iteration, because functional and exploratory testing are technology-facing activities that need the rebuilt legacy core and therefore have to wait for the maintenance window.

The distribution is left to each tester's own judgement during the iteration and is deliberately kept outside the Definition of Done, which covers development activities such as code review and merge rules.

Grow the end-to-end suite until every combination of fare rule and payment method is exercised there, because end-to-end runs give the most precise localisation of the failing component.

Move all end-to-end runs into a hardening iteration before each release, treating the hardening iteration as the team's normal place for doing integration work.

Retire end-to-end testing as soon as the pipeline deploys several times a day and rely on production observability instead, since deployment frequency is the factor that decides end-to-end scope.

Holistic testing suits the audited calculation rules because systems thinking produces the documented evidence a regulator asks for, while formal testing suits the claim journey because its repeatability absorbs frequent change more cheaply.

Both areas should use formal testing, because the drawbacks of holistic testing - difficult to measure, requires a culture change, heavily context-dependent - outweigh its benefits anywhere a regulator is involved in some part of the product.

Both areas should use holistic testing, because the drawbacks of formal testing - excessive rigidity, delayed feedback, low cognitive engagement - make it a poor fit once a team has moved to iterative delivery.

An incremental regression approach re-runs the complete suite in every iteration, whereas a risk-based approach re-runs the complete suite only before a release, so the two differ in execution frequency rather than in test selection.

A collaborative regression approach means the automation engineers alone own the regression suite, whereas an exploratory regression approach means the business representatives execute the scripted regression cases on their behalf.

An exploratory regression approach substitutes unscripted sessions for the suite and, unlike the other four approaches, leaves no record of what was covered, which is why it is used only when the suite is abandoned.

A hardening iteration is an iteration set aside for elaborating and refining the next batch of user stories, while a user journey is a test case that exercises a single screen of the check-out in depth.

A bug bash is the overnight automated execution of the regression suite, while a feature toggle is a version-control branch that keeps unfinished check-out work away from the trunk.

A user journey is the ordered sequence of build and deployment steps the pipeline performs for the check-out, while a hardening iteration is the iteration in which the team agrees its Definition of Done.

Generalization is pursued until both specialisms are spread evenly over the three zones, after which the specialist roles are dismantled, because the syllabus treats retained specialization as the cause of silos.

With so little overlap each zone should be given one fixed speciality and all matching work routed to it, because specialization is the syllabus answer to a narrow overlap window between locations.

The ratio of generalists to specialists is set by the syllabus rather than by context, so a streaming team applies the same proportion as a team working under medical device regulation.

Ask them to sign off a test plan at the end of each iteration, so their involvement is concentrated in one formal approval that does not compete with the overlap hours.

Hand their acceptance testing to the team's own test automation specialist and send them the results afterwards, so their limited availability stops constraining the iteration.

Log every ambiguity found in the eligibility rules as a defect assigned to the business representatives, so that the accumulated rework makes the cost of their absence visible to management.

The tester takes over writing the developer's component tests so the developer can concentrate on production code, which the chapter presents as the tester's main contribution to the development team.

The tester waits until the developer marks the story complete and then sends a written defect report in the next overlap window, which keeps the two roles separate and the feedback objective.

The tester joins code reviews only to confirm that coding standards were followed, and invites the developer into exploratory sessions only once the release has been streamed to viewers.

Brief them thoroughly on the design intent and the acceptance criteria first, then keep the same small group across several iterations so that their feedback becomes more consistent and comparable over time.

Use them at the end of the release as an extra pass over the structured test cases, since their purpose is to add execution capacity once the regression suite has outgrown the team.

Use them in place of structured testing in volatile products such as live streaming and video games, where the syllabus positions them as the team's primary source of quality information.

In behavior-driven development a tester writes the behavioural tests once the developers have finished the increment, and a tissue tester is a team member who rotates into a testing role for one iteration.

Acceptance test-driven development differs from behavior-driven development in that the first is performed only by business representatives and the second only by developers, with testers taking part in neither.

A tissue tester is an automated check that is discarded after a single execution, and behavior-driven development is the practice of writing behaviour in a formal notation for external audit.

All test planning is done once at release level, because planning inside a two-week iteration would duplicate decisions already taken for the quarter and only the release-level Definition of Done is binding.

All test planning is done inside each iteration, because the release scope emerges from the iterations, so a release-level test strategy and release readiness assessment are not needed in Agile delivery.

Iteration planning covers the release-wide quality risk assessment and the integration points with the meter data collection network, while release planning covers the high-level test conditions and the readiness of test data for each story.

Monitoring compares actual test execution against a baselined iteration test schedule, and control means the test manager reassigning testers whenever the recorded variance exceeds the agreed tolerance for the iteration.

Monitoring is limited to the automated test results in the pipeline, because those are the only objective data available inside an iteration, and control is exercised only at the release readiness assessment.

Monitoring is replaced by the Definition of Done, so no measurement is needed during the iteration, and control consists of refusing to accept any story whose acceptance criteria changed after iteration planning.

Requirements coverage should be reported against a separate traceability matrix maintained outside the backlog, because acceptance criteria are too volatile to serve as traceable units.

Infrastructure and environment coverage is not reportable in Agile delivery, because environments are provisioned on demand and therefore have no stable configuration to measure against.

The four coverage types should be combined into one weighted index so the steering group receives a single comparable figure per iteration.

The two teams' metrics are published side by side each iteration so the better-performing team's practices can be mandated for the other, which the syllabus presents as the fastest route to organisation-wide improvement.

Improvement is driven by an external assessor who audits both teams against a maturity model and issues a ranked improvement plan, because self-assessment lacks the objectivity Agile teams need.

Improvement work is deferred until the metrics have stabilised over several quarters, because acting on a single iteration's data risks local optimization and the syllabus therefore rules out short experiments.

A dark launch deploys the new tariff logic and switches it on for all customers at midnight without prior announcement, while a canary release deploys it to a full replica environment for a final regression run.

A community of practice is the governance board that approves each team's test plan before an iteration starts, while Goal-Question-Metric is the practice of collecting all available pipeline metrics and later selecting the useful ones.

A canary release and a dark launch are two names for the same mechanism, and both describe running the new version alongside the old one and comparing outputs before switching over.

Because the third-party entitlement and payment provider offers staging only two afternoons a week, plan the entitlement and payment coverage as end-to-end runs concentrated in those two afternoons and treat that as the Quadrant 1 contribution for the release.

Because the date is fixed and capacity is short, drop Quadrant 3 activity for the tournament and reinstate business-facing product critique such as usability and exploratory work only after the closing match.

Because leadership has named a single unacceptable outcome, replace the quadrant-based outline with a risk register alone, since the quadrants describe test types rather than a way of allocating effort across a project.

Read the two curves together as evidence that individual developers are committing less carefully since iteration 4, and report the reopened share per developer at the next iteration review so ownership becomes visible.

Because the new checks arrived in iteration 4, set a code coverage target for the tariff-rating component for the next quarter and make progress towards that percentage the team's improvement goal.

Because both curves rise together, conclude that the second curve is caused by the first and act only on feedback time, since a single root cause makes any further measure redundant for this quarter.

The production monitoring data is treated as the requirement for award-letter generation, since what the live system currently does is by definition what the business needs it to do.

The two-year-old requirement document is formally retired and archived, after which the automated test scripts become the requirement because no other written source remains for the team to consult.

The test charters are used as the requirement for award-letter generation, since a charter states a mission and scope and therefore already contains the expected results that the letters must satisfy.

Storyboarding produces the test cases for the journey and testboarding reviews them afterwards for defects, so the two techniques form a sequential design-then-review pair used once per feature.

Testboarding visualises the user journey from the persona's point of view while storyboarding visualises the coverage of main and alternative scenarios, which is why testboarding is run with the business representative and storyboarding with the developers.

Both techniques are performed after the journey has been implemented, because their purpose is to document what was built so that the team has a maintainable record for the next release.

Twelve examples under one rule show the rule is well understood and ready to implement, and the seven open questions can be resolved during implementation because example mapping is time-boxed rather than exhaustive.

Five business rules against one story is the imbalance to act on, and the correct response is to split the story into five stories, one per rule, keeping the original acceptance criteria on each of them.

The session should continue past its time box until every red card has been converted into a green one, because unanswered questions are the only outcome example mapping is designed to remove.

The problem is confirmation bias in the support team, which recorded only the calls that matched its expectation, so the countermeasure is to re-code the support call data before drawing conclusions about the journey.

The unanimity in review shows bias was absent, because a shared view across a cross-functional team is the syllabus indicator that the story has been examined from several perspectives.

The countermeasure is to make one team member formally responsible for challenging every story, since concentrating the challenge in a single accountable role is how the syllabus removes bias from refinement.

The tester records promptly as a defect against the requirement and asks the business analyst to reissue the specification, since requirements engineering supports shift left by moving defect reporting earlier in the lifecycle.

The tester leaves the wording as it is and writes an exploratory test charter to discover what promptly turns out to mean once the tariff calculation has been implemented and deployed to staging.

The tester rewrites the requirement as a state transition diagram, because the syllabus lists semi-formal scenario models as the specification form that satisfies all five validation criteria on its own.

Send the abstract rule statements to an AI tool to generate acceptance criteria and test scenarios, then have the business representative approve the generated set, so the scarce overlap time is spent on approval rather than on discussion.

Postpone the acceptance criteria until the eligibility screens have been implemented, then walk the business representative through the working software, since a running screen is the most concrete basis for a conversation.

Ask the business representative to write the acceptance criteria alone between sessions and have the team refine whatever arrives, so no shared time is consumed and the domain knowledge reaches the team directly.

Testware means the tools the team uses to design and execute its tests, and shift left means moving the test execution stage nearer the start of the release calendar without changing the activities themselves.

A test session sheet is the template on which the iteration test plan is recorded, and the test basis is the environment and data configuration against which the tests are run.

Specification by example means illustrating a finished specification with examples once it has been approved, and testware is the subset of test work products that has been automated.

Three slices following the architecture: first the itinerary and seat data model, then the booking and payment services, then the traveller-facing screens, with the original eight acceptance criteria attached unchanged to each slice so nothing is lost between them.

Two slices by outcome type: one slice covering the whole journey when everything succeeds, and a second slice covering every error and expiry case across search, seat selection and payment, so the exceptional behaviour can be scheduled later.

Three slices by the people available: one for the developer who knows the legacy reservation core, one for the front-end developer, and one for the tester to cover payment, with the acceptance criteria distributed between them as the work is picked up.

One slice per payment option, with the original six acceptance criteria attached to each slice so that the reviewer of any slice can still see the complete intended behaviour, and with the ambiguous partial-payment criterion left as written for the team to interpret per option.

Two slices by settlement timing: one covering the options that settle immediately and one covering the options that settle later, since grouping by timing keeps the number of slices small and each slice still delivers a working payment path.

Four slices by reconciliation effort: one slice implementing the payment capture for all four options, and three further slices adding reporting, reconciliation and customer notification across all options at once.

Heuristics are formal test design techniques whose steps produce a repeatable set of test cases from a given specification, which is why the syllabus places them alongside boundary value analysis and decision table testing.

Heuristics are checklists maintained by the team for its own product, so published sources such as usability heuristics or the OWASP Top 10 fall outside the definition and are treated as standards instead.

Heuristics substitute for a test oracle, because a rule of thumb about how a feature should behave provides the expected result that thin acceptance criteria fail to supply.

FEW HICCUPPS lists the product dimensions to cover, so the tester should use it to widen coverage, while SFDIPOT supplies the oracles against which billing output is compared.

RCRCRC is the mnemonic to use for the oracle problem here, because its Repaired and Chronic elements identify the parts of the billing engine whose behaviour can be trusted as a reference.

TERMS should be applied to widen the product dimensions, since Tools and Technology, Execution and Maintenance together describe the aspects of the metering product a tester should visit.

Each tour is a scripted sequence of steps through one district that is repeated identically in later iterations, which is what makes tours suitable as a regression suite for the booking portal.

A single session must visit all six districts in a fixed order, because the districts are defined as consecutive layers of the product from the interface inwards to the data.

Tours are grouped by the role of the person running them - the business district for business representatives, the hotel district for operations staff - which is how the districts get their names.

The moderator takes the driver role at the keyboard so the group can concentrate on observing, and rotation happens once per hour so that each participant has time to settle into the role before handing it on.

Only the navigator and the driver take part actively while the rest of the group works on other tasks and is called in when a defect needs confirming, which is what distinguishes mob testing from pair testing.

A session runs for a full working day so that the whole commentary selector can be covered in one sitting, and the retrospective is deferred to the team's regular iteration retrospective to save time.

Pair testing is unsuitable for mentoring, so the junior tester should work alone and bring findings to the senior tester afterwards, which removes both the fatigue and the dominance problem at once.

The pair should be extended into a mob so the workload is spread over more people, since the syllabus recommends escalating from pair testing to mob testing whenever fatigue appears.

The senior tester should keep the decision-making role permanently so the junior tester can observe without pressure, because differing testing styles within a pair are the drawback the syllabus warns about most.

It is the practice of having the language model generate the test cases from the same prompt that produced the code, so that the tests and the implementation are guaranteed to be consistent with the stated intent.

It is a standardised AI-assisted test level positioned between component integration testing and system testing, applied whenever any part of a product was generated from a prompt.

It is an informal first impression of the user interface recorded by the tester before any structured testing begins, similar to the feedback a tissue tester gives on a prototype.

A test smell is a defect found in a test case during review, so every smell recorded against the appeal-submission cases has to be corrected before those cases may be executed.

An edge case is any test case derived from an alternative scenario in the story, and an epic is a user story that has been estimated as too large for a single iteration.

A test charter is the session record produced after exploratory testing, containing the coverage achieved and the anomalies observed, while a test smell is the term for an area of the product that has historically been defect-prone.

Convert the web and mobile acceptance criteria directly into the charters for those channels and treat them as the complete test oracle for the two channels, so that exploration there needs no further oracle notes.

Defer any charter for the paper channel until the document-recognition service has been procured and its acceptance criteria written, because a charter cannot be framed as a testable hypothesis without acceptance criteria to derive it from.

Set charter priorities in proportion to each channel's share of production traffic, so the web channel receives roughly twenty times the session time of the paper channel and the ordering is defensible from data.

A charter aimed at the business district, because 10 recorded areas is the highest count and a district that has already attracted the most attention is the one where the team's understanding is deep enough to make a further session productive.

A charter that spreads the 90 minutes evenly across all six districts, so that the recorded counts become comparable and the coverage chart can be reported to the iteration review as balanced.

No further session is chartered, because three sessions have already recorded thirty areas and the remaining time is better spent turning the session sheets into scripted regression cases for the historical district.

Continue with the payment variations to use the remaining 20 minutes productively and record them under the same charter, since the session sheet documents what was actually covered and the charter can be updated afterwards to match.

Extend the session beyond 90 minutes until the behaviour with differing expiry times can be judged, because a session should not close while an observation in the session sheet is still unresolved.

Close the session immediately and defer all four anomalies and both questions to the iteration retrospective, since a session that produced no new findings in its last 20 minutes has reached the point of diminishing returns and needs no review of its own.

It is Hardcoded Test Data, because the case refers to direct debit, card and prepay accounts and to half the amount instead of parameterising the account type and the payment amount. The solution is to move these values into a data table referenced by the case.

It is Bulk Steps, because step 2 combines waiting for a collection date, making a payment and performing a status check in a single numbered step. The solution is to break each action into its own numbered step so each has a verifiable outcome.

It is Copy-Paste Duplication, because step 3 instructs the tester to repeat step 2 with a different amount rather than stating the steps again. The solution is to write the repeated steps out in full so each case is self-contained.

Hidden Dependencies: the cases rely on state created elsewhere in the suite, and the solution is to document in each case which other cases must have run before it, so that a tester picking up TC-43 knows what to execute first.

Environment Assumptions: the cases assume a particular state of the entitlement environment, and the solution is to add a shared environment precondition at the top of the suite describing the viewer and pass data the whole suite expects.

No Cleanup or Teardown: TC-41 leaves a viewer signed in and TC-42 leaves an active pass, and the solution is to add a teardown step to each case so the suite always finishes in its starting state.

Automate the upgrade-offer banner first, because the parts of the product that change most often are where automated regression protection pays back fastest, and defer the entitlement checks since they are already stable.

Automate the exploratory sessions on the commentary selector by scripting the routes the testers took, so that the exploration becomes repeatable and the manual effort can be redirected to the entitlement checks.

Decide the automation scope in a separate technical planning session held outside the iteration, because deciding it at iteration planning would make the iteration content harder to predict for the business representatives.

The syllabus names the specific products in each category so that teams can standardise on the same toolchain, which is what makes results comparable between teams delivering the same product.

Tool choice should start from the categories the team is already comfortable with, since familiarity shortens the feedback loop more than aligning the tools to a test strategy would in a daily-deployment setting.

Configuration management and continuous integration tools fall outside the test tool categories, because they support the build rather than the testing and therefore belong to the development toolchain.