CTFL-AcT ISTQB Certified Tester - Acceptance Testing (CT-AcT) Questions and Answers

Decision Model and Notation (DMN) is a standardized approach used to model decision logic, often represented in decision tables that evaluate inputs and determine outputs. In this scenario, the entitlements granted to a candidate are based on the total score from two exams, where:

Each exam can be graded as either 0 or 1.

The combined score can be 0, 1, or 2.

The entitlements depend on the combined result:

0 → No entitlements

1 → Partial entitlements

2 → Full entitlements

Among the given diagrams:

Option A simply lists test cases but lacks explicit logic modeling.

Option B shows a mapping from total score to entitlements but doesn't model how the total is derived from the two exams.

Option C redundantly splits outputs into multiple Boolean fields and doesn't reflect how the decision is made from exam inputs.

Option D is the correct representation.

Option D uses:

e1 and e2 as inputs for Exam #1 and Exam #2.

Result as the sum of e1 + e2.

A final Output mapped based on the Result:

0 → No

1 → Partial

2 → Full

This structure accurately follows the DMN standard by expressing inputs, a derived result, and the corresponding decision output, making Option D the correct and most complete decision model.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 2.3):

“Decision tables are commonly used to express business rules that determine outputs based on combinations of inputs. DMN formalizes this structure to support automated reasoning.”

Usability testing aims to evaluate the ease of use, efficiency, and satisfaction with which users can achieve tasks. When checking the ergonomics (e.g., layout, visual clarity, interaction comfort), checklist-based evaluations are particularly useful.

Option A is correct because a checklist of ergonomic/usability heuristics (e.g., Nielsen’s heuristics, ISO 9241 standards) allows evaluators to systematically assess whether the interface meets established usability criteria.

Other options:

B (Biometrics-based evaluation) tracks physiological responses (e.g., stress or eye movement), which are useful but indirect and less targeted to ergonomic checks.

C (Walkthroughs) help assess usability by observing task flows, but they are less focused on layout and ergonomic design.

D (Log file analysis) captures behavior but not directly ergonomic issues like spacing, font size, or element alignment.

Answer: A. Checklist-based evaluation

Acceptance Test-Driven Development (ATDD) is a collaborative approach in which acceptance criteria are defined early, often before implementation starts. Business process models (e.g., BPMN) and business rule models (e.g., DMN) are essential tools to formalize how the system should behave under various conditions.

In ATDD, these models provide a structured representation of system workflows and decision logic, which can then be used by testers and stakeholders to derive or generate acceptance tests. This ensures that testing is aligned with actual business processes and requirements.

Option C is correct because it aligns with the purpose of ATDD: to use business models as a foundation for deriving acceptance tests in collaboration with business analysts, testers, and developers.

Other options:

A is incorrect — models are created as part of the project, not necessarily before it starts.

B is incorrect — models support and clarify acceptance criteria; they do not replace them.

D is incorrect — models are maintained as living documentation, especially in agile and iterative approaches.

Answer: C. In an ATDD approach, testers use business process and business rule models to generate acceptance tests.

Ensuring traceability between requirements (user stories) and test cases is a cornerstone of quality assurance in acceptance testing. It confirms that all business needs are covered by corresponding tests and helps assess the impact of changes. Traceability matrices or tools are used to track these links throughout the lifecycle.

Option B is correct because regularly verifying and updating traceability ensures that acceptance test coverage remains aligned with evolving requirements — a best practice in quality assurance.

Other options:

A (review of source code) is a white-box technique, more suitable for unit or integration testing.

C (checklist-based verification of requirements) is useful but focuses on requirement quality, not directly on testing activities.

D (eye tracking) is a usability evaluation technique and not standard for verifying test case feasibility.

Answer: B. Verification of the traceability between user stories and test cases to make sure it is up to date.

An acceptance test summary report is a high-level document produced at the end of acceptance testing. It provides stakeholders (especially business owners and decision-makers) with essential information to determine whether the system meets the acceptance criteria and whether it is ready for release.

Option A is correct because understanding the residual risk — based on test results, open defects, and coverage — is critical for release decisions. The summary report includes test execution status, significant findings, defect summaries, and an overall risk assessment.

Other options:

B (technical details on defect fixes) belong more in defect or technical reports, not in the acceptance summary.

C (test strategy/design methods) are part of the test plan, not the summary report.

D (test procedure info) is operational detail, not suited for a high-level summary report.

Answer: A. Information to evaluate the level of risk for product release.

Comprehensive Detailed Explanation (Approx. 200 words):

Acceptance criteria should focus on business-relevant outcomes that are specific, testable, and observable. In this user story, the goal is to validate that the registration functionality is available and behaves as expected.

Let's analyze each proposition:

i) “A registration form is displayed on the screen.”

→ Valid. It is observable, specific, and directly aligned with the user story.

ii) “The form is written in the Groovy language; the cursor is initially set on the ‘login’ field...”

→ Invalid as acceptance criteria. It contains implementation details (e.g., “Groovy language”) irrelevant to business stakeholders. Also, low-level UI behavior like cursor position is overly technical and not a business-driven criterion.

iii) “I cannot register myself if the login I choose is used by another player.”

→ Valid. It defines system behavior based on a business rule (unique login) and is testable.

iv) “After successful registration process I am informed about it by an e-mail.”

→ Valid. It describes a user-visible outcome after registration, which is observable and testable.

Correct answer: D. only i), iii), and iv) are well-written acceptance criteria.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 1.3.2):

“Acceptance criteria must describe the externally visible and verifiable system behavior, excluding implementation details.”

The best Gherkin-style acceptance tests are business-oriented, behavior-driven, and avoid unnecessary technical or UI details. They describe actions in a way stakeholders can understand, focusing on system behavior rather than implementation mechanics.

Option A follows Gherkin conventions:

GIVEN clearly describes the system state (account balances).

WHEN describes a user action (transferring funds).

THEN describes a verifiable outcome (account balances updated correctly).

Option B includes unnecessary UI actions like clicking buttons or field names, which are implementation-specific and violate the abstraction level expected of acceptance tests.

Option C uses appropriate structure but introduces incorrect balances in the THEN step (possibly a typo; $4500 on X is wrong if funds were transferred from Y to X).

Option D uses improper syntax — WHEN is misused as another GIVEN, and THEN describes a computation rather than a system behavior.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 2.2.2):

“Acceptance criteria in BDD are best captured through Gherkin scenarios that are understandable by business stakeholders and focus on expected outcomes, not implementation details.”

==================

Acceptance Test-Driven Development (ATDD) involves early collaboration between stakeholders to define acceptance criteria and tests before development begins. Using business process models in ATDD helps visualize user behavior, align test cases with real workflows, and serve as living documentation.

Option C is the least meaningful argument because:

Business process models abstractly describe workflows and decisions at a business level. While they help clarify requirements and detect requirement-related defects, they do not directly support detecting defects in the application code, which is typically the focus of unit and integration testing, not acceptance testing.

Let’s validate the other options:

A is a strong argument — process models clarify use cases for testers.

B is valid — graphical models help visualize test coverage directly.

D is true — as business process models evolve, they remain valuable artifacts aligned with current system behavior and requirements.

Answer: C. Business process models will make it easier to detect defects in the application code.

In Gherkin syntax (Given-When-Then), the purpose is to describe system behavior in a way that’s understandable to all stakeholders. Test steps should focus on user intentions and observable results — not UI implementation details — to ensure maintainability and abstraction.

Line 3 ("click 'Buy Tickets' button") refers explicitly to a UI element, which should generally be avoided in acceptance tests. Instead, it could say "I request to buy tickets."

Line 7 ("I should provide my personal data") is describing an action the user must take, not an outcome or result. In a Gherkin “Then” step, we expect an observable system response, not further user interaction.

Option C identifies both of these review concerns correctly.

Other options:

A includes an incorrect comment about line 4 ("quantity should not be set") — setting a value is acceptable.

B is false — the test case has reviewable issues.

D might be valid in a different context (e.g., boundary tests), but that’s not a flaw in the existing scenario.

Answer: C. Line 3 refers to an element of the user interface, which is to be avoided and line 7 is an action and not a result

Exploratory testing is an unscripted, experience-based testing technique where the tester learns about the system, designs tests, and executes them simultaneously. It is especially effective in Agile environments, where rapid feedback and creative exploration are valuable.

Option D is the least likely action because scripting automated test scripts is a structured activity that typically occurs after exploratory sessions or during more formal test phases. Exploratory testing emphasizes manual exploration, not automation scripting.

Other options:

A is part of the core purpose of exploratory testing — discovering the product.

B is relevant — defining a charter and discussing it with stakeholders (like the Product Owner) helps guide the exploratory session.

C is also relevant — results of exploratory tests should be documented and communicated.

Answer: D. Scripting of the automated test scripts

Test reports summarize the results of test execution and are often used by stakeholders, including business owners and release managers, to make informed decisions about whether to release a product. If these reports are ambiguous, incomplete, or inaccurate, the decisions based on them could be flawed, leading to reputational damage, customer dissatisfaction, or regulatory issues.

Option A is correct because it highlights the risk of basing critical go/no-go decisions on poor-quality reporting.

Other options:

B describes a problem with test case implementation, not test reporting.

C mentions public perception, which might be influenced by report quality, but it is secondary to the internal decision-making purpose.

D refers to human error during test execution or design, not the purpose of reviewing test reports.

Answer: A. If the test reports are unclear or incomplete, the decision to release the product can be based on non-reliable information

Gherkin is a structured language used in Behavior-Driven Development (BDD) to define test cases in a clear, business-readable format. It follows the GIVEN-WHEN-THEN structure:

GIVEN describes the precondition (system’s state before the action).

WHEN describes the action/event.

THEN describes the expected result or outcome.

Analyzing the phrases:

ii) “The elevator is on the Ground Floor” is a precondition — fits GIVEN.

i) “The total weight of passengers is greater than 200 kg” is an action or state change — fits WHEN.

vi) “A message ‘too many passengers’ is displayed on the screen” is the expected outcome — fits THEN.

Thus, Option A correctly maps these elements to form a well-structured Gherkin scenario.

Other options are incorrect because:

Option B misplaces an expected outcome as an action.

Option C misrepresents the order — “login” isn’t a precondition.

Option D introduces two THEN elements and violates the typical Gherkin structure.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 2.2.2):

“Gherkin test cases use GIVEN-WHEN-THEN structures to make the behavior of the system under test understandable by all stakeholders.”

User Experience (UX) requirement analysis is a critical component of acceptance testing and product development. According to ISTQB Acceptance Testing syllabus and industry-aligned UX design methodologies (e.g., ISO 9241-210 and BABOK guidelines), UX requirement analysis is typically structured around the following pillars:

User Analysis – Understanding who the users are (roles, goals, experience levels)

Task Analysis – Understanding what users do (tasks, workflows, pain points)

Context Analysis – Understanding where and how users interact with the product (environmental and contextual factors)

Competitor Analysis – Understanding how similar problems are solved in the market

Option B best describes Task Analysis, one of the most practical and impactful pillars. In task analysis, business analysts and UX researchers observe how users interact with current or comparable systems to understand workflow patterns, user frustrations, needs, and required system functionality. This method helps uncover implicit needs that users may not articulate in interviews.

This approach is aligned with ISTQB’s emphasis on understanding real-world usage and business processes as a foundation for deriving acceptance criteria and tests. It supports the creation of realistic scenarios that reflect actual user behavior, which is essential for verifying system fitness for use.

The other options are inaccurate:

A refers to psychological disposition, which is more aligned with user profiling or persona development, not a core focus of user analysis in requirement engineering.

C incorrectly ties context analysis with deriving security requirements, which is not its purpose.

D describes an unrealistic or incorrect method for competitor analysis.

Therefore, Option B is the best description of a key pillar of UX requirement analysis per industry and ISTQB standards.

Acceptance criteria must be concrete, testable, and focused on observable system behavior. They define what the system must do to satisfy a requirement and help determine whether the requirement has been successfully implemented.

REQ 3.28 states: “The automated system records critical credit application data (CCAD) needed to support application screening.” From this, we infer that the system must persistently store this data after data entry.

Option A is the best match because it provides a specific, observable behavior (CCAD being stored in a MySQL database after a successful entry) that can be verified through acceptance testing. It’s a measurable outcome, aligned with the requirement's objective.

Other options are less suitable:

Option B introduces new behavior (displaying a message) not directly tied to the original requirement.

Option C is vague ("quick and reversible") and lacks measurable criteria.

Option D refers to usability guidelines, which is not directly relevant to the storage functionality stated in the requirement.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 1.3.2):

“Well-written acceptance criteria are unambiguous, testable, and focused on observable results.”

Comprehensive Detailed Explanation (Approx. 200 words):

Acceptance criteria are an essential part of requirements engineering and test design. According to the ISTQB CTFL Acceptance Testing Syllabus, acceptance criteria are defined as a set of statements that specify what must be true for a system, feature, or user story to be considered acceptable to stakeholders. These criteria are used as the basis for developing acceptance test cases and help bridge the communication between stakeholders, business analysts, developers, and testers.

They are not exclusive to Agile frameworks (contrary to option A); while common in Agile (e.g., as part of a user story), they are equally valuable in traditional lifecycles. Option B is incorrect because testers are encouraged to collaborate in defining acceptance criteria early to ensure testability and clarity. Option C incorrectly states that acceptance criteria replace acceptance tests in ATDD (Acceptance Test-Driven Development). In fact, acceptance criteria are transformed into acceptance tests during ATDD.

Exact Reference – ISTQB CTFL Acceptance Testing Syllabus (Section 2.1):

“Acceptance criteria describe the conditions under which a requirement, user story, or business process is considered successfully implemented. They provide the foundation for acceptance testing and serve as input to test case development.”

Therefore, option D is the most accurate.

Clear, complete, and testable requirements or user stories are critical for effective acceptance testing. Ambiguities or vague statements lead to differing interpretations by stakeholders, developers, and testers. This often results in software that doesn’t meet user expectations or in tests that fail to verify business needs correctly.

Option B is correct because it highlights the importance of precise requirements in both implementation and testing phases. Ambiguities can result in incorrect behavior, untestable features, or test cases that don’t align with business goals.

Other options:

A is risky — while testers may explore assumptions during exploratory testing, relying on assumptions rather than clarification increases risk.

C is incorrect — the INVEST mnemonic helps write better user stories, but it doesn’t replace review or validation processes.

D is false — Agile still values requirements engineering; it’s more collaborative and incremental, with the product owner playing a key role, not diminishing its importance.

Answer: B. Vague or ambiguous requirements may lead to misunderstandings both during implementation and testing

The goal here is to achieve full decision coverage (also known as branch coverage), which means each decision point in the process must evaluate to both TRUE and FALSE at least once during testing.

From the BPMN ATM withdrawal model, we identify two key decisions:

Is the balance ≥ $100?

If yes, is receipt = YES?

To achieve full decision coverage:

One test must evaluate decision 1 as TRUE and another as FALSE.

If decision 1 is TRUE, then decision 2 must be exercised both ways (receipt = YES and NO), but for minimal decision coverage, one path through decision 2 is enough.

Analyzing test cases:

Test 1 (balance = $100, receipt = YES): decision 1 = TRUE, decision 2 = TRUE

Test 2 (balance = $99): decision 1 = FALSE

These two tests ensure:

Decision 1 evaluated TRUE (Test 1) and FALSE (Test 2)

Decision 2 evaluated at least once (receipt = YES in Test 1)

Thus, Test 1 and Test 2 form the minimal set for full decision coverage.

Other options:

C and D are redundant for the minimal set.

A includes an extra test not needed for minimal decision coverage.

Answer: B. Test 1, Test 2

ISO/IEC 25010 defines two key quality models:

Product Quality Model (e.g., Usability, Security, Portability)

Quality in Use Model — which includes characteristics of the user’s experience when interacting with the product in a real-world context.

The four main characteristics of the Quality in Use model are:

Effectiveness

Efficiency

Satisfaction

Freedom from risk

Option A — Efficiency is one of the key Quality in Use characteristics, as it refers to the resources used to achieve goals with accuracy and completeness.

Other options:

B (Usability), C (Compatibility), and D (Portability) are characteristics of the Product Quality Model, not of Quality in Use.

Therefore, the correct answer, as per ISO 25010:2011, is:

Answer: A. Efficiency

Beta testing is a form of external user acceptance testing where real users test the product in their environment before the official release. It helps identify issues that may not have been caught in internal testing and gather user feedback on functionality, usability, and performance in real-world conditions.

Option C is correct — the core goal of beta testing is to obtain user feedback in their actual usage context, providing insight into how the system performs outside of controlled environments.

Other options:

A: Test charters are used in exploratory testing, not typically in beta testing.

B: Incorrect — beta testing is not tied to the timing of user story development in Agile.

D: Incorrect — beta testing is performed by end users, not by internal team members like developers or business analysts.

Answer: C. Beta testing aims to obtain feedback from users in their context of use

In acceptance testing, testers execute test cases that are directly derived from user stories or requirements via their acceptance criteria. During execution, testers compare the actual outcome of the system with the expected result described in the acceptance criteria. If there's a mismatch (a deviation), it is documented as a defect or discrepancy.

This process is essential for validating that the system meets business needs. The tester’s role includes reporting clear, objective findings—not fixing the defect or deciding its severity (which might involve developers or business analysts).

Option A is incorrect: Business analysts may support testing, but execution is primarily a tester’s responsibility.

Option C is not fully correct: While developers may fix defects, assignment and triage follow a formal workflow and do not happen automatically.

Option D is incorrect: Business analysts don’t repeat test executions; this is the tester’s responsibility.

Non-functional quality attributes (also called quality characteristics) such as usability, reliability, operability, performance, and maintainability are often validated during acceptance testing to ensure the system behaves as expected under real-world conditions.

Option C is correct because operability — a subcharacteristic of usability per ISO 25010 — refers to the degree to which users can operate and control the system effectively. Acceptance testing often involves running the system in realistic settings to validate these aspects.

Other options:

A (Modularity and reusability) are more relevant to system architecture and design, not acceptance testing.

B is incorrect — time behavior (performance) can and should be tested at multiple levels, including system and integration testing before acceptance.

D is misleading — testing basic functionality is necessary, but it does not address non-functional quality attributes.

Answer: C. During acceptance testing, the operability of the product is checked in a realistic environment