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 the syllabus therefore treats the monthly maintenance window as the only point at which the team is permitted to record a completed test result against its agreed Definition of Done.

Only white-box testing stays inside the iteration, because functional and exploratory testing are business-facing activities that cannot be judged until the rebuilt legacy core is available, and the syllabus therefore assigns every business-facing test type to the period after the iteration, once real fare rules, seat inventory and the surrounding reservation interfaces can be exercised together.

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 how much end-to-end scope a decomposed platform still needs to keep.

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 as soon as any part of the product is audited, so the presence of one regulated component settles the approach for the entire backlog.

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, and the choice between them follows from how long one full run takes.

A collaborative regression approach means the automation engineers alone own the regression suite and decide its scope, whereas an exploratory regression approach means the business representatives execute the scripted regression cases on their behalf during the monthly maintenance window.

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 root cause of silos and regards a fully interchangeable team as the end state of the whole team approach.

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, and concentrating a skill in one place is what stops deep expertise being diluted across the team.

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 the acceptance testing to the team's own test automation specialist and send the business representatives the results afterwards, so that their limited availability stops constraining the iteration at all.

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 both to management and to their own directorate at the next review.

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 and as the way to keep component test design in testing hands.

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, which the syllabus treats as the condition for using it in a release decision.

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 and treats their first impressions as sufficient evidence for a release decision.

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 by business representatives and the second by developers, with testers contributing only once both sets of tests exist, because each practice belongs to the role that owns the artefact.

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 the syllabus makes only the release-level Definition of Done binding, so iteration planning is limited to confirming which stories the team pulls from the backlog and in what order it will deliver them.

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, because risk work needs the detail that only an iteration backlog provides, and story-level data is easier to arrange once the quarterly scope is fixed.

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, since a burn-down chart reports remaining story effort rather than test progress and therefore cannot serve as an instrument for monitoring the test effort.

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 torn down after each run, so there is no stable configuration left to measure the coverage 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 because it narrows the variation between the teams.

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 in favour of trends gathered across releases.

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, so the remaining four iterations can be spent entirely on the playback path that leadership named as the unacceptable failure.

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 have been committing less carefully since iteration 4, and report the reopened-defect share per developer at the next iteration review so that ownership becomes visible and the people whose commits trigger the longest pipeline runs can be coached individually.

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 one is caused by the first and act only on feedback time, since a single shared root cause makes any further measure redundant for this quarter and keeps the improvement effort focused.

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 the syllabus treats testware as a form of requirements precisely when 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 a scope for a session and therefore already carries the expected results that each letter must satisfy, which makes a separate written statement of intent unnecessary.

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 during refinement and storyboarding is left to the developers once the technical design of the journey has been settled.

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 that the rule is well understood and ready to implement, and the seven open questions can be carried into the iteration and answered during implementation, because example mapping is time-boxed and produces a rough first sketch rather than an agreed scope.

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 unchanged on each of them so that nothing agreed in the session is lost in the slicing.

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 logged only the calls matching its expectation of who struggles with the journey, so the countermeasure is to re-code the support call data against a neutral taxonomy before any conclusion is drawn about the hardship-payment stories or the way they were reviewed.

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 before refinement continues, since requirements engineering supports shift left by moving formal defect reporting to an earlier point 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 one specification form that satisfies all five validation criteria on its own, so no further elicitation is needed.

Send the abstract rule statements to an AI tool to generate the acceptance criteria and the test scenarios, then have the business representative approve the generated set inside the overlap window, so that the scarce shared time is spent approving a finished proposal rather than on a discussion the team has no room for.

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 an already finished specification with examples once the business has formally approved it, and testware is the subset of test work products that the team has so far managed to automate.

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 that nothing is lost between them and every slice can be reviewed against the complete intended behaviour of the booking journey before the team accepts it as finished.

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 of settlement, and with the ambiguous partial-payment criterion left exactly as written so that each slice team can interpret it for its own option when the work is picked up.

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, lets the team reuse a single settlement test setup for each group, and still leaves every slice delivering a working payment path that the customer can use end to end.

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 defined 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 as a source of measurable coverage.

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 has been stabilised by earlier fixes and can therefore be trusted as the reference the thin acceptance criteria fail to supply.

TERMS should be applied to widen the product dimensions, since Tools and Technology, Execution, Reporting and Maintenance effort together describe the aspects of the metering product that a tester should set out to 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 the regression suite for the booking portal and what lets the team compare the results of one tour with the results of the same tour a month earlier.

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, the tourist district for new customers - which is how the districts get their names and how each tour is assigned to a tester.

The moderator takes the driver role at the keyboard so that the rest of the group can concentrate on observing the commentary selector, and rotation happens once per hour so that each participant has time to settle into the role properly before handing it on to the next person waiting in the mob queue.

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 separates 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 the entitlement flow alone and bring findings to the senior tester afterwards, which removes the fatigue and the dominance problem at once and leaves the senior tester free for the complex features.

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 that the junior tester can observe without pressure, because differing testing styles within a pair are the drawback the syllabus warns about most strongly and a single decision-maker keeps the style of the session consistent.

It is the practice of having the language model generate the test cases from the same prompt that produced the appeal-submission screen, so that the tests and the implementation are derived from one agreed statement of intent and cannot drift apart as the screen is changed.

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 and re-reviewed before any of those cases may be executed again in the portal.

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 two channels and treat them as the complete test oracle there, so that exploration on the web and app paths needs no further oracle notes and the tester's time goes to the channels whose criteria are still missing.

Defer any charter for the paper channel until the document-recognition service has been procured and its acceptance criteria have been written, because a charter has to be framed as a testable hypothesis and the recognition behaviour cannot be stated as a hypothesis while the supplier of that service is still unknown.

Set charter priorities in proportion to each channel's share of production traffic, so that the web channel receives roughly twenty times the session time of the paper channel and the resulting ordering stays 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 one further session productive before the review.

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, which keeps the sheet and the charter consistent with each other and avoids spending fresh setup time on a second session just for a few extra variations.

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 the retrospective is where the team already discusses what it learned during the iteration and decides what to change.

It is Hardcoded Test Data, because the case names direct debit, card and prepay accounts and half the amount instead of parameterising the account type and the payment amount. The solution is to move those values into a data table that the case references, so that one run of the case can be made for each row of that table and the branches disappear.

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, the pass data and the sign-in state that the whole suite expects before any of its cases are executed by a tester.

No Cleanup or Teardown: TC-41 leaves a viewer signed in and TC-42 leaves an active pass, so the solution is to add a teardown step to each case that returns the suite to 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 a check that has been stable for many months is unlikely to reveal a new failure and can safely be left to manual confirmation shortly before the tournament.

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, who would see the estimates for a story move each time the team added automation work to it after refinement had already sized the story.

The syllabus names the specific products in each category so that teams can standardise on one toolchain and compare their results with each other.

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, where any learning curve costs the team a day of delivery.

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.