CTFL_Syll2018 ISTQB Certified Tester Foundation Level (Syllabus 2018) Questions and Answers

•  The test objectives for user acceptance testing of the first release of a new software product aimed at a general market and built using Agile methods are D. c and d. User acceptance testing is a level of testing that involves users or customers validating that the software product meets their needs and expectations before accepting it for use or deployment. User acceptance testing can have different objectives depending on the context and purpose of the software product. For a new software product aimed at a general market and built using Agile methods, some possible objectives are:

A detailed explanation of user acceptance testing can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 79-80.

The test organization that has the highest level of independence is C. Independent test specialists for specific test types, such as usability, performance or certification test specialists. Test independence refers to the degree of separation between the tester and the developer or user of the system or component under test. Test independence can help to reduce bias and increase objectivity in testing. Independent test specialists are testers who have specialized skills and knowledge in specific test types or domains and who are not involved in the development or use of the system or component under test. Independent test specialists can provide more reliable and accurate results than testers who are part of the development team or user community. A detailed explanation of test independence can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 9-10.

State transition testing is a technique that uses state transition diagrams as a test basis to derive test cases2. A state transition diagram shows the states of a system and the transitions between them triggered by events or conditions2. A test case can cover one or more state transitions, depending on the test objective and coverage criterion2. In this question, the test cases (i) and (ii) cover different sets of state transitions, as shown below:

Test Case

State Transitions

(i) X-Z-V-W

S1 – S2 – S3 – S4 – S2

(ii) W-Y-U-U

S4 – S2 – S4 – S4 – S4

Dynamic analysis tools are used to find defects, such as memory leaks, while software is executing. Dynamic analysis tools monitor the behavior and performance of the software under various conditions and report on any anomalies or errors. Dynamic analysis tools are not used to determine differences between files or databases, which is a function of comparison tools. Dynamic analysis tools are not used to measure the percentage of specific types of code structure that have been exercised, which is a function of code coverage tools.

A consideration when deploying test execution tools is B. Recorded manual tests may become unstable in use. Test execution tools can record manual tests performed by a tester and replay them automatically on demand. However, recorded manual tests may become unstable or unreliable in use, due to various factors, such as changes in the system under test, changes in the test environment, changes in the user interface, timing issues, synchronization issues, etc. Therefore, recorded manual tests may require frequent maintenance or modification to keep them up to date and consistent with the system under test. A detailed explanation of recorded manual tests can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 112-113

The Cambrian Pullman Express has special ticketing requirements represented by the partial decision table below. The decision table has six columns representing six rules and eight rows representing eight conditions or actions. The table is filled with “Y” and “N” values indicating whether a particular condition is met for a particular rule.

!decision table

Carol has a student railcard and is travelling on a Flexible Standard Class ticket. James has a senior railcard and is travelling on a super saver ticket. The question asks which of the options represents the correct actions for these two test cases. To answer this question, we need to find the matching rule for each test case and then look at the corresponding actions. For Carol, the matching rule is rule 2, as she has a student railcard (Y) and a Flexible Standard Class ticket (Y). The actions for rule 2 are: OK to travel (Y), eligible to upgrade (Y), and concessionary fare (N). Therefore, Carol is OK to travel and eligible to upgrade, but not entitled to a concessionary fare. For James, the matching rule is rule 6, as he has a senior railcard (Y) and a super saver ticket (N). The actions for rule 6 are: OK to travel (N), eligible to upgrade (N), and concessionary fare (N). Therefore, James cannot use the service, is not eligible to upgrade, and is not entitled to a concessionary fare. Among the options given in this question, only A correctly represents these actions. A says that Carol is eligible to upgrade and James cannot use the service. Therefore, A is the correct answer.

The diagram lists various types of operating systems (LNX, W2K, WSP), databases (ORA, MSQ, SQL), and application servers (JBS, WSP) supported by the application under test. To test all possible combinations of these types, we need to multiply the number of options in each category. In this case, we have:

• 3 options for operating systems
• 3 options for databases
• 2 options for application servers

Therefore, we have 3 x 3 x 2 = 18 possible combinations to test.

However, if we look closely at the diagram, we can see that some combinations are not valid or feasible because they are not connected by lines. For example, we cannot test LNX with WSP as an application server because there is no line between them. Similarly, we cannot test W2K with JBS as an application server because there is no line between them. Therefore, we need to exclude these invalid combinations from our calculation.

If we count only the valid combinations that are connected by lines in the diagram, we get:

• 5 combinations for LNX (LNX-ORA-JBS, LNX-ORA-WSP, LNX-MSQ-JBS, LNX-MSQ-WSP, LNX-SQL-JBS)
• 5 combinations for W2K (W2K-ORA-WSP, W2K-MSQ-WSP, W2K-SQL-WSP)
• 5 combinations for WSP (WSP-ORA-JBS, WSP-ORA-WSP, WSP-MSQ-JBS, WSP-MSQ-WSP)

Therefore, we have 5 + 5 + 5 = 15 valid combinations to test.

You can find more information about testing combinations in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 4, Section 4.22.

The fundamental test process activity where the sufficiency of testing and resulting information are assessed is Evaluating exit criteria and reporting. This activity involves checking whether the test objectives have been met and whether there are any unresolved issues or risks that could affect the release or deployment decision. This activity also involves preparing and communicating a test summary report that summarizes the test activities and results and provides recommendations and feedback for improvement. You can find more information about Evaluating exit criteria and reporting in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 3, Section 3.5.

How to fix the defect is not needed to specify in a defect report because it is not part of the information that is required to describe, reproduce, and prioritize the defect. How to fix the defect is part of the solution or resolution that is provided by the developers or maintainers who are responsible for correcting the defect. A defect report is a document that records and communicates the details of a defect found during testing. A defect report typically includes the following information:

• Defect ID: A unique identifier for the defect
• Summary: A brief description of the defect
• Severity and priority: An indication of how serious and urgent the defect is
• Test environment details: A description of the hardware, software, network, data, tools, etc., that were used when the defect was found
• How to reproduce the defect: A step-by-step procedure to recreate the defect
• Expected and actual results: A comparison of what should have happened and what actually happened when the defect occurred
• Attachments: Any additional information or evidence that can help understand or resolve the defect, such as screenshots, logs, files, etc.

You can find more information about defect reports in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 5.

The ‘Standard for Software Test Documentation’ specification (IEEE 829) is a standard that defines a set of documents that can be used to document the test process and its outcomes. The standard provides an outline for each document, specifying its purpose, content, and format. However, the standard does not prescribe how to apply it in different contexts or projects. It is up to each organization or project to decide how to adapt the standard to their specific needs and situation. Therefore, the standard is not a rigid or mandatory requirement that must be followed strictly by all testers. Rather, it is a flexible and adaptable guideline that can be used as a reference or a starting point for creating test documentation regimes. You can find more information about IEEE 829 and test documentation in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 51.

The requirement given in

the image specifies

the charge for

a money transfer based on

the amount

of money transferred.

The amount can be anywhere from 1 to 5000 euros, with different charges applied for different ranges of amounts.

To test this requirement, we can use equivalence partitioning, which is a specification-based test technique that involves dividing the input or output values into groups or partitions that are expected to be treated in the same way by the system under test. For example, based on the requirement, we can identify the following equivalence partitions for the input amount:

• EP1: Amount < 1 (invalid)
• EP2: 1 <= Amount <= 1999 (valid, charge = 10 euros)
• EP3: 2000 <= Amount <= 5000 (valid, charge = 15 euros)
• EP4: Amount > 5000 (invalid)

The set of amounts that covers all equivalence partitions is C. 0-100-2000-6000. This set of amounts includes one value from each equivalence partition and ensures that all possible scenarios are tested. For example:

• TC1: Amount = 0 -> Invalid input
• TC2: Amount = 100 -> Valid input, charge = 10 euros
• TC3: Amount = 2000 -> Valid input, charge = 15 euros
• TC4: Amount = 6000 -> Invalid input

The other sets of amounts do not cover all equivalence partitions because they either include values that belong to the same partition or exclude values that belong to different partitions. For example:

• A. 0-1999-2000-5000 -> This set of amounts does not cover all equivalence partitions because it includes two values that belong to EP2 (1999 and 2000) and excludes any value that belongs to EP3.
• B. 1-2000-5001-10000 -> This set of amounts does not cover all equivalence partitions because it includes two values that belong to EP4 (5001 and 10000) and excludes any value that belongs to EP2.
• D. 99-1-2000-4999.99 -> This set of amounts does not cover all equivalence partitions because it includes a value that is not an integer (4999.99), which violates the assumption that only integer values can occur.

You can find more information about equivalence partitioning in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

A software company decided to buy a commercial application for its accounting operations. As part of the evaluation process, the company decided to assemble a team to test a number of candidate applications. The most suitable team for this goal would be a team with a mix of software testers and experts from the accounting department. This team would have the following advantages:

• Software testers have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company. They can also use tools and techniques to support their testing activities and provide reliable and objective information about the quality and risk level of each candidate application.
• Experts from the accounting department have the knowledge and expertise to understand and validate the functionality and usability of each candidate application. They can also provide feedback and suggestions for improvement based on their needs and expectations as end users or customers.

The other teams mentioned in the question are not as suitable for this goal as they are for other purposes or scenarios. For example:

• A team from an outsourcing company which specializes in testing accounting software: This team might have the skills and experience to test accounting software, but they might not have the knowledge and expertise to understand and validate the specific requirements and criteria of the company that wants to buy the application. They might also lack the communication and collaboration with the stakeholders of the company who are involved in the evaluation process.
• A team of users from the accounting department that will need to use the application on a daily basis: This team might have the knowledge and expertise to understand and validate the functionality and usability of each candidate application, but they might not have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company. They might also lack the tools and techniques to support their testing activities and provide reliable and objective information about the quality and risk level of each candidate application.
• A team from the company’s testing team, due to their experience in testing software: This team might have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company, but they might not have the knowledge and expertise to understand and validate the functionality and usability of each candidate application. They might also lack the feedback and suggestions for improvement based on the needs and expectations of the end users or customers.

Static analysis tools are tools that examine the code or design of a software system without executing it. Static analysis tools can be used to find defects, measure complexity, check compliance, or improve quality. Some examples of defect types that can be found by static analysis tools are:

• Variables that are never used: This defect type occurs when a variable is declared but not referenced or assigned in the code, which indicates a waste of memory or a logic error.
• Coding standard violations: This defect type occurs when the code does not follow the predefined rules or conventions for formatting, naming, commenting, etc., which affects the readability and maintainability of the code.
• Uncalled functions and procedures: This defect type occurs when a function or procedure is defined but not called or invoked in the code, which indicates a waste of resources or a missing functionality.

Memory leaks are defect types that are least likely to be found by static analysis tools because they are related to the dynamic behavior and performance of the software system. Memory leaks occur when a program does not release memory that it has allocated, causing the system to run out of memory and slow down or crash. Memory leaks can only be detected by dynamic analysis tools that monitor the memory usage of the program during execution. You can find more information about static analysis tools in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 6, Section 6.3.

To achieve 100% statement coverage, you need to execute every statement in the code at least once. In this case, you need two test cases: one where condition A is true and one where condition A is false. This way, you can cover both the DO B statement and the END IF statement. You can find more information about statement coverage in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 4, Section 4.31.

Maintenance testing is a type of testing that is performed after a software product has been delivered and deployed to ensure that it still meets its requirements and functions correctly after changes have been made to it or to its environment. Changes can include corrective changes (fixing defects), adaptive changes (adapting to new platforms or environments), perfective changes (improving performance or usability), or preventive changes (avoiding potential problems). One of the appropriate reasons for maintenance testing is to verify that the software product works as expected after upgrading the operating system, which is an example of an adaptive change. Other reasons for maintenance testing can include verifying that the software product works as expected after fixing defects, adding new features, improving performance, or preventing future issues. You can find more information about maintenance testing in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 12.

A use case is a description of how a user interacts with a system to achieve a goal or perform a task. A use case typically consists of a sequence of steps or actions that the user and the system perform to complete the goal or task. A use case can be used as a basis for designing test cases that verify the functionality and usability of the system under test. A test sequence that represents a possible use case should follow the logical order and flow of the user-system interaction and cover the main scenario and possible variations or exceptions. For example, based on the test cases given for a Library Management System, we can identify the following use cases:

• UC1: Add a new borrower to the system
• UC2: Update a borrower’s data
• UC3: Remove a borrower from the system
• UC4: Loan a book to a borrower
• UC5: Return a book from a borrower
• UC6: Reserve a book for a borrower
• UC7: Send “reservation ready” message to a borrower

The test sequence that represents a possible use case is D. 1-2-6-7-4-5-3. This test sequence follows the logical order and flow of the user-system interaction and covers the main scenario and possible variations or exceptions. For example:

• TC1: Add a new borrower to the system -> This is the first step of the use case, where the user registers as a new borrower in the system.
• TC2: Update a borrower’s data -> This is a possible variation of the use case, where the user updates their personal or contact information in the system.
• TC6: Reserve a book for a borrower -> This is the second step of the use case, where the user reserves a book that they want to borrow from the library.
• TC7: Send “reservation ready” message to a borrower -> This is the third step of the use case, where the system sends a message to the user informing them that their reserved book is ready for pickup.
• TC4: Loan a book to a borrower -> This is the fourth step of the use case, where the user picks up their reserved book from the library and loans it from the system.
• TC5: Return a book from a borrower -> This is the fifth step of the use case, where the user returns their borrowed book to the library and returns it to the system.
• TC3: Remove a borrower from the system -> This is a possible exception of the use case, where

the user decides to cancel their membership and remove their account from the system.

The other test sequences do not represent possible use cases because they do not follow the logical order and flow of the user-system interaction or they do not cover the main scenario and possible variations or exceptions. For example:

• A. 1-4-2-7-5-6-3 -> This test sequence does not follow the logical order and flow of the user-system interaction because it performs some steps before or after they are supposed to happen. For example, it performs TC4 (Loan a book to a borrower) before TC6 (Reserve a book for a borrower), which does not make sense because the user cannot loan a book that they have not reserved yet.
• B. 1-6-2-5-7-4-3 -> This test sequence does not follow the logical order and flow of the user-system interaction because it performs some steps before or after they are supposed to happen. For example, it performs TC5 (Return a book from a borrower) before TC4 (Loan a book to a borrower), which does not make sense because the user cannot return a book that they have not loaned yet.
• C. 1-6-4-7-5-3-2 -> This test sequence does not cover the main scenario and possible variations or exceptions because it omits some steps that are essential for completing or terminating the use case. For example, it omits TC2 (Update a borrower’s data), which is a possible variation of the use case that allows the user to change their personal or contact information in the system.

You can find more information about use cases and test sequences in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

Testing tools can be used by both developers and testers for different purposes and at different stages of the software development life cycle. For example, developers can use tools such as unit testing frameworks, code coverage tools, debugging tools, static analysis tools, etc., to improve the quality of their code and find defects early. Testers can use tools such as test management tools, test design tools, test execution tools, test data preparation tools, performance testing tools, etc., to support their testing activities and increase their efficiency and effectiveness. The use of testing tools does not necessarily imply test automation, which is the use of software to perform or support test activities that would otherwise require manual intervention. Test automation is a complex and costly process that requires careful planning, design, implementation, maintenance, and evaluation. The use of testing tools also does not change the role of the test team, which is still responsible for defining the test strategy, designing the test cases, analyzing the test results, reporting the defects, etc. You can find more information about testing tools and test automation in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 61.

Pair programming is a software development technique where two programmers work together on the same code at the same workstation. One programmer, called the driver, writes the code while the other programmer, called the navigator, reviews the code and provides feedback and suggestions. Pair programming is not only a coding technique but also an informal review method because it involves constant communication and collaboration between the programmers who check each other’s work and share their knowledge and skills. Pair programming can improve the quality and productivity of software development by reducing defects, increasing code readability, enhancing learning opportunities, and fostering creativity and innovation. Pair programming is usually used in agile methods such as Extreme Programming (XP), Scrum, or Kanban. It is not an alternative term for code inspection, which is a formal review method where a group of reviewers examine a piece of code in a structured and systematic way following predefined rules and roles. It is also not done with developer and tester pairing together because pair programming requires both programmers to have similar levels of expertise and familiarity with the code they are working on. You can find more information about pair programming in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 31.

A decision table is a specification-based test technique that involves creating a table that shows the combinations of inputs and outputs for a system under test based on certain conditions and rules. A decision table can be used to design test cases that cover all possible scenarios and outcomes for a system under test. Some statements about decision tables are:

• I. Generally, decision tables are generated for low risk test items: This statement is false because decision tables can be generated for any level of risk test items depending on the complexity and variability of the system under test. Decision tables are especially useful for testing systems that have many inputs, outputs, conditions, and rules that affect their behavior or performance.
• II. Test cases derived from decision tables can be used for component tests: This statement is true because decision tables can be used to design test cases for any level or type of testing, including component tests. Component tests are tests that verify individual components or units of software in isolation from other components or systems.
• III. Several test cases can be selected for each column of the decision table: This statement is true because each column of the decision table represents a unique combination of inputs and outputs for the system under test based on certain conditions and rules. Therefore, each column can be used as a basis for selecting one or more test cases that cover that combination.
• IV. The conditions in the decision table represent negative tests generally: This statement is false because the conditions in the decision table can represent both positive and negative tests depending on the requirements and expectations of the system under test. Positive tests are tests that verify that the system under test behaves as expected under valid or normal inputs or conditions. Negative tests are tests that verify that the system under test handles errors or exceptions gracefully under invalid or abnormal inputs or conditions.

You can find more information about decision tables in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

Memory leaks are errors that occur when a program does not release memory that it has allocated, causing the system to run out of memory and slow down or crash. Memory leaks cannot be detected by structure-based testing techniques, which are based on the code structure and logic. Structure-based testing techniques can only find errors that are related to the control flow, data flow, or logic of the program. For example, they can find errors such as features that are only partially implemented, data structures that are used before initialization, or division by zero. To detect memory leaks, you need dynamic analysis tools that monitor the memory usage of the program during execution. You can find more information about structure-based testing techniques and dynamic analysis tools in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 4, Sections 4.2 and 4.31.

The requirement given in the image specifies a field asking for the number of group members, which can be anywhere from 2 to 20 visitors. To test this requirement, we can use boundary value analysis, which is a specification-based test technique that involves testing the values at or near the boundaries of an equivalence partition. An equivalence partition is a set of values that are expected to be treated in the same way by the system under test. For example, based on the requirement, we can identify two equivalence partitions for the input group size:

• EP1: Group size < 2 (invalid)
• EP2: Group size = 2 (valid)
• EP3: 2 < Group size < 20 (valid)
• EP4: Group size = 20 (valid)
• EP5: Group size > 20 (invalid)

The boundary values for each equivalence partition are the values at or near the edges of the partition. For example, the boundary values for EP1 are -1 and 1. The boundary values for EP2 are 1 and 2. The boundary values for EP3 are 2 and 19. And so on.

To test this requirement using boundary value analysis, we need to select one value from each boundary and test it with different combinations of valid and invalid inputs. For example, we can select the following values:

• BV1: Group size = -1 (from EP1)
• BV2: Group size = 1 (from EP1 and EP2)
• BV3: Group size = 2 (from EP2 and EP3)
• BV4: Group size = 19 (from EP3 and EP4)
• BV5: Group size = 20 (from EP4 and EP5)
• BV6: Group size = 21 (from EP5)

We can then create test cases using these values and different combinations of valid and invalid inputs. For example:

• TC1: Group size = -1 -> Invalid input
• TC2: Group size = 1 -> Invalid input
• TC3: Group size = 2 -> Valid input
• TC4: Group size = 19 -> Valid input
• TC5: Group size = 20 -> Valid input
• TC6: Group size = 21 -> Invalid input

Therefore, we need a minimum of 6 valid test cases to achieve 100% boundary value coverage based on input group size.

You can find more information about boundary value analysis in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

Functional testing is an example of black-box dynamic testing. Functional testing is the process of testing the functionality or behavior of a software system based on its requirements or specifications. Functional testing does not require any knowledge of the internal structure or implementation of the system under test; it only focuses on what the system does rather than how it does it. Functional testing is also an example of dynamic testing because it involves executing the software system with selected inputs and observing its outputs and effects on the environment. Dynamic testing is different from static testing, which involves examining the software system without executing it, such as code inspection, static analysis, etc. You can find more information about functional testing and dynamic testing in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 21.

A tool type is a category of tools that have similar features and functions and can be used for similar purposes. A test manager is a person who is responsible for planning, monitoring, controlling, and reporting the test activities and results. A test manager needs to use tools that can help them with these tasks and provide them with useful information and insights. Some examples of tool types that are useful for a test manager are:

• Defect tracking tool: This tool type allows the test manager to record, track, manage, and report the defects found during testing. It also helps the test manager to communicate with developers, testers, and other stakeholders about the defect status and resolution.
• Test management tool: This tool type allows the test manager to organize, manage, and control the test process and its outcomes. It also helps the test manager to define the test strategy, plan the test activities, allocate the test resources, schedule the test execution, monitor the test progress, and evaluate the test results.
• Requirements management tool: This tool type allows the test manager to manage and trace the requirements of the system under test. It also helps the test manager to ensure that the test objectives are aligned with the user needs and expectations and that the test coverage is adequate and complete.

The other tool types mentioned in the question are not as useful for a test manager as they are for other roles or purposes. For example:

• Modeling tool: This tool type allows the user to create graphical or textual representations of software systems or processes. It can be used for design, analysis, simulation, or documentation purposes.
• Static analysis tool: This tool type allows the user to examine the code or design of a software system without executing it. It can be used for finding defects, measuring complexity, checking compliance, or improving quality.
• Coverage measurement tool: This tool type allows the user to measure how much of the code or design of a software system has been exercised by a set of test cases. It can be used for evaluating the effectiveness or completeness of testing.

You can find more information about tool types in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 61.

One of the basic principles of testing is that for a software system, it is not possible under normal conditions to test all input and output combinations because they are too many and too complex to cover within a reasonable time and budget. Therefore, testers have to select a subset of inputs and outputs that are representative and relevant for testing based on criteria such as requirements, risks, priorities, etc. This principle implies that testing cannot prove that a software system is defect-free or has a certain level of quality because there might be some untested inputs or outputs that could reveal defects or failures. Testing can only provide information about the quality and risk level of a software system based on the observed behavior and results under certain conditions and assumptions. You can find more information about the basic principles of testing in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 11.

A configuration management tool is a tool that allows users to manage and control the versions and changes of software artifacts, such as code, documents, test cases, etc. A configuration management tool can help prevent the loss of Sam’s updates by:

• Providing a centralized repository where Sam can store and retrieve his test cases and other artifacts
• Keeping track of the history and status of each artifact and allowing Sam to compare and revert to previous versions if needed
• Supporting collaboration and communication among team members by allowing them to share and access the latest versions of the artifacts

The other tools mentioned in the question are not relevant for this scenario because they do not provide the same functionality or benefits as a configuration management tool. For example:

• A. Incident management tool: This tool type allows users to record, track, manage, and report the defects found during testing. It does not help with managing or controlling the versions or changes of test cases or other artifacts.
• C. Test execution tool: This tool type allows users to execute test cases automatically or semi-automatically and compare the actual results with the expected results. It does not help with managing or controlling the versions or changes of test cases or other artifacts.
• D. Backup tool: This tool type allows users to create copies of data or files and store them in a different location or device for recovery purposes. It does not help with managing or controlling the versions or changes of test cases or other artifacts.

You can find more information about configuration management tools in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 6, Section 6.4.

Functional and structural tests are alternative test types that may be used separately or together at B. All test levels. Functional testing is a type of testing that verifies the functionality of the system or component under test against its requirements or specifications. Functional testing focuses on what the system or component does, not how it does it. Structural testing is a type of testing that verifies the structure or code of the system or component under test. Structural testing focuses on how the system or component does it, not what it does. Functional and structural testing can be used separately or together at any test level, such as unit testing, integration testing, system testing, acceptance testing, etc. Functional and structural testing can complement each other by providing different perspectives and coverage of the system or component under test. A detailed explanation of functional and structural testing can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 25-26.

• The question asks which of the test cases will exercise both outcomes from decision 2. Decision 2 is represented by node B in the flow graph. Node B has two outcomes: edge 2 (P > Q) and edge 3 (P <= Q). Therefore, to exercise both outcomes from decision 2, we need to choose a test case that covers both edge 2 and edge

• Among the options given in this question, only B covers both edge 2 and edge
• In B, P =36 > Q =36 for edge 2 and P =37 <= Q =35 for edge
• Therefore, B is the correct answer.

An item or event that could be verified by one or more test cases. A test condition is a general term that refers to anything that can be tested by a test case, such as a requirement, a function, a feature, a use case, a user story, etc. A test condition is derived from the test basis (the source of information for testing) and serves as an input for test design and test case creation. A test condition can be expressed in natural language or in a formal notation. A detailed explanation of test condition can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 17-18.

The main reason for using a pilot project to introduce a testing tool into an organization is C. To assess whether the tool will be cost-effective. A pilot project is a small-scale trial or experiment that is used to evaluate the feasibility, benefits, risks, and challenges of introducing a testing tool into an organization. A pilot project can help to assess whether the tool will be cost-effective, by comparing the costs of acquiring, deploying, using, and maintaining the tool with the benefits of using the tool, such as increased efficiency, effectiveness, quality, etc. A pilot project can also help to identify any technical, organizational, or human factors that may affect the successful adoption of the tool, and plan for any necessary actions or changes to address them. A detailed explanation of pilot projects can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 115-1161.

These are the four test levels defined for a common V-model testing approach, according to the ISTQB Foundation Level 2018 Syllabus. Unit testing is another term for component testing, and maintenance testing is not a test level, but a type of testing that can be performed at any level.

The test tools that would be classified as test execution tools are D. b and d. Test execution tools are tools that automate the execution of test cases or test scripts, and compare the actual results with the expected results. Test execution tools can also record and replay user actions, generate test data, and report test results. Test harness and test comparators are examples of test execution tools. A test harness is a tool that creates a test environment for a component or system under test, by simulating the required dependencies, such as stubs, drivers, or mock objects. A test comparator is a tool that compares the actual outputs of a component or system under test with the expected outputs, and reports any differences or anomalies. A detailed explanation of test execution tools can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 111-1121.

Performance, Load, Stress. Performance testing is a type of non-functional testing that measures how well the system performs under various conditions, such as response time, throughput, resource utilization, etc. Load testing is a type of performance testing that simulates a high volume of user requests or transactions on the system and measures its behavior under normal and peak load conditions. Stress testing is a type of performance testing that simulates extreme or abnormal conditions on the system and measures its behavior under stress or overload conditions. These test types would help verify the requirements such as minimum number of enquiries per hour, availability, and response time under peak loads. A detailed explanation of performance, load, and stress testing can be found in Software Testing Foundations: A Study Guide for the Certified Tester Exam, pages 187-1913.

Data-driven is the type of automation test design that is used in the example below. Data-driven testing is a technique to separate the test data from the test scripts and store them in external sources, such as text files, databases, spreadsheets, etc. Data-driven testing allows the test scripts to read the test data from these sources during test execution, which makes the test scripts more reusable and maintainable1 explains data-driven testing as follows:

Data-driven testing is a software testing methodology that is used in the automation testing framework to store the test data in a table or spreadsheet format. This allows automation engineers to have a single test script that can execute tests for all the test data in the table.

Data-driven testing helps to increase the efficiency of automated testing by reducing the number of test scripts required for different scenarios. It also helps to improve the quality of testing by covering more variations of input data and expected results.

A, C, and D are incorrect answers. Dynamic test design, keyword-driven, and data coverage analysis are not types of automation test design that are used in the example below. Dynamic test design is a technique to generate test cases based on dynamic analysis of the system behavior or output during test execution. Keyword-driven testing is a technique to create test scripts using keywords that represent actions or commands that can be executed by an automation tool. Data coverage analysis is a technique to measure and evaluate how much of the input domain or data set has been covered by the test cases.

Testers being involved in reviewing documents as soon as they are approved is not a characteristic of good testing, independent of the development life cycle model. Testers should be involved in reviewing documents as soon as drafts are available, not after they are approved, as this can help to detect defects early, improve communication and collaboration, and reduce rework and costs2 states this as follows:

Testers should be involved in reviewing documents such as requirements specifications or user stories as soon as drafts become available in order to provide early feedback on testability aspects such as clarity, consistency, completeness, correctness, unambiguity etc.

Early involvement of testers in reviewing documents can help to prevent defects from being introduced into later phases of development or testing by identifying potential issues or gaps before they become embedded in the system under test.

A, B, and C are characteristics of good testing, independent of the development life cycle model. Each test level having objectives specific for the test level (A) ensures that testing is aligned with the purpose and scope of each level and provides clear criteria for success. Every development activity being matched by a corresponding testing activity (B) ensures that testing is integrated with development and provides continuous feedback on quality and progress. Testers being involved in reviewing documents as soon as drafts are available © ensures that testing is performed early and throughout the life cycle and provides input on testability aspects.

After completing the tool selection and a successful proof-of-concept, introducing the selected tool into an organization generally starts with a pilot project, which has the following objectives12:

• Gaining in-depth knowledge about the tool, understanding both its strengths and weaknesses
• Evaluating how the tool fits with existing processes and practices, and determining what would need to change
• Assessing whether the benefits will be achieved at reasonable cost
• Identifying and resolving any technical and organizational issues before deploying the tool on a larger scale
• Providing training, coaching, and mentoring for users of the tool
• Defining metrics to measure the success of the tool deployment

Therefore, the option D is the most typical objective of running a pilot project, as it is essential to ensure the compatibility and suitability of the tool with the current way of working, and to identify any potential risks or challenges that may arise from the tool introduction12.

The other options are not typical objectives of running a pilot project, because they are either part of the tool selection process, or the outcomes of the pilot project. They are:

• To establish whether the tool is available for a free trial period (and for how long) (A). This is part of the tool selection process, which involves gathering information about the tool features, costs, support, and availability12. This should be done before running a pilot project, as it helps to narrow down the list of potential tools and to conduct a proof-of-concept12.
• To provide training, coaching, and mentoring for users of the tool (B). This is an outcome of the pilot project, which aims to increase the competence and confidence of the tool users and to facilitate the tool adoption12. This should be done during and after the pilot project, as it helps to ensure the effective and efficient use of the tool and to address any issues or feedback from the users12.
• To develop a clear set of requirements and objective criteria against which the tool can be evaluated ©. This is also part of the tool selection process, which involves defining the tool requirements based on the needs and expectations of the stakeholders, and establishing the evaluation criteria based on the benefits and risks of the tool12. This should also be done before running a pilot project, as it helps to compare and rank the potential tools and to select the most suitable one12.

References:

• ISTQB Foundation Level 2018 syllabus
• Chapter 6 - Tool Support for Testing | PPT

I and II are false statements about static analysis. Static analysis cannot be used instead of dynamic testing (I), as it cannot verify the behavior or performance of the system under test at runtime. Static analysis can uncover defects like security vulnerabilities (II), as it can detect potential weaknesses or flaws in the source code that may lead to security breaches. defines static analysis as follows:

Static analysis is a type of software testing that analyzes the source code or other software artifacts without executing them. Static analysis can be used to check conformance to specifications and standards, detect syntax and logical errors, measure complexity and quality metrics, identify code smells and bad practices, find potential security vulnerabilities, and improve maintainability and readability.

III and IV are true statements about static analysis. Static analysis can be used to check conformance to specifications and standards (III), as it can compare the source code or other software artifacts against predefined rules or criteria. Static analysis typically detects failures prior to component testing (IV), as it can be performed early in the development cycle before compiling or executing the code.

 According to the syllabus, a tester’s ability to communicate about defects, test results, and other test information well is an important skill that contributes to testing effectiveness and efficiency. A tester should be able to communicate clearly, accurately, objectively, constructively, politely, and persuasively with various stakeholders involved in testing or affected by testing outcomes. A tester should also be able to use appropriate communication methods and tools depending on the context and purpose of communication. The answer A is correct because it is an example of a tester’s ability to communicate about defects, test results, and other test information well. Emphasizing the benefits of testing means highlighting how testing adds value to the software product and the business goals. This can help to gain support and trust from stakeholders and foster a positive attitude towards testing. The other answers are incorrect because they are examples of poor communication skills that can hinder testing effectiveness and efficiency. Taking a command-and-control approach with the project team (B) means imposing one’s own decisions or opinions without considering others’ inputs or feedback. This can create conflicts and resentment among team members and reduce collaboration and cooperation. Being firm and assertive with test findings and information © means insisting on one’s own views or demands without being flexible or open-minded. This can lead to arguments and disagreements with stakeholders who may have different perspectives or expectations. Writing subjective defect reports and review findings (D) means using personal, biased, or unobservable information that does not support the evaluation or analysis of defects or tests. This can cause confusion and misunderstanding among stakeholders who may not be able to reproduce or verify the defects or tests.

References: Certified Tester Foundation Level Syllabus, Section 1.5.1, page 19-20.

State transition testing is the most suitable test technique for this situation. State transition testing is a technique that uses scenarios based on state diagrams to test the behavior of a system or component that can change its state in response to events or inputs. A state diagram is a graphical representation of the states that a system or component can be in, the events or inputs that can trigger a change of state (transitions), and the actions or outputs that can occur as a result of a change of state. In this case, the vending machine for light drinks can be modeled as a state diagram with states such as “idle”, “coins inserted”, “drink selected”, “drink dispensed”, “change returned”, “sold out”, etc., and transitions triggered by events such as “button pressed”, “coins inserted”, “drink dispensed”, “change returned”, etc. State transition testing can help design test cases that cover all the possible states and transitions of the vending machine and verify its functionality and usability.

References: Certified Tester Foundation Level Syllabus, Section 4.5.1

The correct answer is A, as it states that the Wideband Delphi estimation technique is an example of the expert-based approach. The Wideband Delphi estimation technique is a method of estimating testing effort or duration by using a structured group process that involves multiple experts2. The experts provide their estimates independently and anonymously, then compare and discuss them until they reach a consensus2. This technique is an example of the expert-based approach, which is an approach that relies on the knowledge and experience of experts to estimate testing activities2. Option B is incorrect, as it states that the Wideband Delphi estimation technique is an example of the metrics-based approach. The metrics-based approach is an approach that uses historical data and mathematical formulas to estimate testing activities2. This approach does not involve experts or group processes. Option C is incorrect, as it states that burndown charts used in Agile development is an example of the expert-based approach. Burndown charts are graphical tools that show the amount of work remaining versus time in an Agile project2. They are used to monitor and control testing progress and quality. They are not examples of the expert-based approach, as they do not rely on experts’ opinions or estimates. Option D is incorrect, as it states that burndown charts used in Agile development is an example of the risk-based approach. The risk-based approach is an approach that uses risk analysis to prioritize and estimate testing activities2. This approach involves identifying and assessing risks based on their likelihood and impact. It does not involve burndown charts or Agile development. References: 2, Section 2.6

 Boundary value analysis and decision table testing are the best choice of one black box technique and one white box technique for test case design2. A black box technique is a technique that uses the external behaviour or specification of a system as a test basis to derive test cases without referring to its internal structure or logic2. A white box technique is a technique that uses the internal structure or logic of a system as a test basis to derive test cases and measure test coverage2. In this question, the system has complex business rules and many branches in the structure of its code components. Therefore, we need to choose a black box technique that can handle complex business rules and a white box technique that can cover many branches.

• Boundary value analysis is a black box technique that tests the values at or near the boundaries of an equivalence partition2. Boundary value analysis can handle complex business rules by identifying the boundary conditions that may cause errors or exceptions in the system’s behaviour2.
• Decision table testing is a white box technique that tests all possible combinations of conditions and actions in a decision logic2. Decision table testing can cover many branches by creating a table that shows how each condition affects each action and then deriving test cases from each row of the table2.

Therefore, boundary value analysis and decision table testing are the best choice of one black box technique and one white box technique for test case design.

According to the syllabus, a defect report is a document that records the occurrence, nature, and status of a defect. A defect report typically includes several fields that provide relevant information about the defect, such as its title, description, priority, status, environment, steps to reproduce, expected result, actual result, etc. The answer A is correct because it suggests adding severity as an additional defect report field. Severity is a measure of the impact of a defect on the system or its users. Severity can help prioritize defects and decide whether they need to be fixed or not. The other answers are incorrect because they suggest adding fields that are already present in the defect report. Test script id is not necessary for a defect report, as it can be inferred from the steps to reproduce. Actual results and expected results are already included in the defect report under what occurred and what should have occurred.

References: Certified Tester Foundation Level Syllabus, Section 5.2.1, page 58-59.

2-point boundary value analysis is a technique that tests the boundary values of valid and invalid partitions with two values each: one at the boundary and one just outside the boundary. For example, if the valid range is 1 to 10, the 2-point boundary values are 1, 2, 9, 10 for the valid partition, and 0, 11 for the invalid partitions. The advantage of this technique is that it reduces the number of test cases compared to 3-point boundary value analysis, which tests one value inside the boundary as well. However, it may miss some defects that occur only with the values inside the boundary.

In this question, the valid partitions are the ranges of spending that correspond to different discounts, and the invalid partitions are the ranges of spending that are below or above the valid partitions. The boundaries are the values of spending that trigger a change in the discount rate. The 2-point boundary values for each partition are:

• Invalid partition below £500: £0, £499
• Valid partition for 5% discount: £500, £501
• Valid partition for 10% discount: £1000, £1001
• Valid partition for 15% discount: £2000, £2001
• Valid partition for 20% discount: £4000, £4001
• Invalid partition above £4000: £4001, £4002

The test cases TC1 and TC2 already cover two of the boundary values: £500 and £2000. Therefore, to achieve 100% 2-point boundary value analysis, we need to write seven more test cases to cover the remaining boundary values: £0, £499, £501, £1000, £1001, £4000, and £4002. Note that £4001 is a boundary value for both the valid and invalid partitions, so we only need to test it once.

References: ISTQB Certified Tester Foundation Level Syllabus v4.0, Chapter 4.2.2, p. 35-36 1; ISTQB Glossary v4.0, p. 16 2; Software Testing - Boundary Value Analysis 2

A peer review is a review done by colleagues at the same organizational level, such as developers, testers, or managers. An informal review without moderator is called a walkthrough. A review done by developers and testers together is called an inspection. A review done by developers only is not a specific type of review.

References: Certified Tester Foundation Level (CTFL) Syllabus - ASTQB, Section 3.1.1, Page 18

It describes how test cases are derived from a use case. A use case is a description of a set of sequences of actions, including variants, that a system performs to yield an observable result of value to an actor1. An actor can be a human user or another system. Test cases are designed to cover various user behaviors, including basic, exceptional or alternative and error behaviors associated with each use case1. Option A is incorrect, as test cases derived from a use case are not based on non-functional requirements such as usability, but on functional requirements that describe what the system does1. Option C is incorrect, as test cases derived from a use case are not created using white-box test techniques, but using black-box test techniques that focus on the inputs and outputs of the system1. Option D is incorrect, as test cases derived from a use case are not based on pair testing, which is a technique that involves two testers working together to find defects1. References: 1, Section 4.2.4

 Load testing is the type of non-functional testing that would verify these requirements, because it measures how well the system performs under normal or expected load conditions1 . Load testing can verify whether up to 100 users can carry out a transaction simultaneously and whether the response time is within 5 seconds1 . The other options are not relevant types of non-functional testing for these requirements. Stress testing measures how well the system performs under extreme or abnormal load conditions1 . Maintenance testing verifies whether an operational system still works correctly after changes or updates1 . Usability testing evaluates how easy and user-friendly the system is for its intended users1 .

Assigning resources for the planned activities is an activity that is appropriate to the test planning stage, because it involves estimating and allocating the necessary human and physical resources for testing . Test planning is the process of defining the objectives, scope, approach, and resources for testing . The other options are not activities that are appropriate to the test planning stage, but rather to other stages of testing. Option A is an activity that is appropriate to the test analysis stage, because it involves analysing the test basis (such as requirements, design, or code) to identify test conditions . Option C is an activity that is appropriate to the test implementation stage, because it involves designing and preparing the test environments (such as hardware, software, network, or data) for test execution . Option D is an activity that is appropriate to the test execution stage, because it involves writing a test execution schedule that defines the order and dependencies of test cases or procedures .

According to the ISTQB Certified Tester Foundation Level Syllabus Version 2018, an informal review is a type of static testing technique that does not follow a defined process and has no formal or minimal entry and exit criteria. The usefulness of an informal review is highly variable and strongly dependent on the reviewers, who may be chosen arbitrarily. Informal reviews are often performed as part of the development process, before the work product is submitted for formal review. The moderator of an informal review may or may not be the author of the reviewed material. An informal review can have a positive impact on the quality of the product, as well as on the level of knowledge of the reviewers.

References: ISTQB Certified Tester Foundation Level Syllabus Version 2018, Section 4.2.1, page 38.

Test implementation and execution is the phase of the test process where test cases are executed and test results are logged. It includes activities such as checking if the preconditions of test execution have been met, executing test cases according to a test procedure, comparing actual results with expected results, logging test results and reporting defects, and repeating test activities as needed. Prioritizing test conditions is not an activity that belongs to test implementation and execution, but rather to test analysis and design, which is the phase where test conditions are identified and test cases are designed. References: Certified Tester Foundation Level Syllabus, Section 4.2.3 and 4.2.4

Non-functional testing is a type of testing that focuses on the quality attributes of the system or its components, such as performance, reliability, usability, security, etc. Non-functional testing can be done at any test level, depending on the test objectives and scope. In this case, the test types that are non-functional tests are:

• Acceptance test: A test level that focuses on verifying whether the system meets the user’s needs and expectations, and whether it is acceptable for delivery or deployment.
• Stress test: A type of performance testing that evaluates the behavior of the system under extreme or abnormal conditions, such as high load, limited resources, or concurrent access.
• Reliability test: A type of testing that evaluates the ability of the system or its components to perform their required functions under stated conditions for a specified period of time.

Therefore, statements I, III, and V are correct.

References: Certified Tester Foundation Level Syllabus, Section 2.3 and 5.4

The statement that incidents cannot be raised during development is not true, because incidents can be raised during any stage of software development life cycle where deviations from expected or desired behaviour are observed . Incidents can be raised during development, review, testing or use of a software product . The other options are true statements about incidents. 

Functional testing is the most appropriate type of testing to review first, after a record of poor-quality software releases. Functional testing is a type of testing that verifies the functionality and behavior of the software against its requirements and specifications. Functional testing can help detect defects such as incorrect menu selection options, new features that do not work, users allowed to change security levels without administrator rights, etc. Functional testing can also help improve the user satisfaction and confidence in the software. Therefore, functional testing should be reviewed first to ensure that it is done effectively and efficiently, and that it covers all the relevant aspects of the software functionality.

References: Certified Tester Foundation Level Syllabus, Section 2.3 and 5.2.2

According to the syllabus, exploratory testing is a technique that involves simultaneous learning, test design and test execution. A tester dynamically designs and executes tests based on their knowledge, exploration of the test item and the results of previous tests. A time-boxed test session is a fixed period of time during which testing is performed. A test charter is a document that contains test objectives, scope, risks and other information to guide the testing. The answer A is correct because it describes an approach that can be used for exploratory testing. The other answers are incorrect because they describe other techniques, such as error guessing (B), compliance testing © and user acceptance testing (D).

References: Certified Tester Foundation Level Syllabus, Section 4.5.2, page 51-52.

Reviewing tests developed by others would not typically be performed by a tester, but rather by a test leader or a peer reviewer1 . Reviewing tests developed by others is an activity that involves checking the quality and completeness of the test cases or procedures and providing feedback or suggestions for improvement1 . The other options are tasks that would typically be performed by a tester. Option A is a task that would typically be performed by a tester, because it involves preparing and acquiring the test data that are needed for executing the test cases or procedures1 . Option B is a task that would typically be performed by a tester, because it involves setting up and checking the test environment that supports the execution of the test cases or procedures1 . Option C is a task that would typically be performed by a tester, because it involves writing test summary reports that document the results and outcomes of the test execution1 .

The fundamental test process consists of five main activities: test planning and control, test analysis, test design, test implementation and execution, and test evaluation and reporting. During the test analysis activity, the testability of requirements is evaluated, meaning that the requirements are checked for clarity, completeness, consistency, verifiability, etc. Test analysis also involves identifying test conditions based on the test basis, such as requirements, specifications, user stories, or use cases.

References: Certified Tester Foundation Level Syllabus, Section 2.4.1 and 4.2.2

Test Cases 1, 2 and 3 are all valid, because they cover all the possible combinations of conditions and actions in the decision table. Test Case 1 covers the case where the employee is not a car or motorcycle driver, which leads to the action of not allowing the expense claim. Test Case 2 covers the case where the employee drives a diesel car with an engine size greater than 1600cc, which leads to the action of accepting the expense claim at band C. Test Case 3 covers the case where the employee rides a motorcycle, which leads to the action of accepting the expense claim at band A12.

Testing has several objectives that aim to provide information and confidence about the quality and risk level of the software product and to support decision-making and improvement processes. Some of these objectives are:

• Finding defects: Testing is the process of finding defects or failures in the software product that do not meet its requirements or expectations.
• Providing information for decision-making: Testing is the process of providing information about the quality and risk level of the software product based on the observed behavior and results under certain conditions and assumptions. This information can help stakeholders make informed decisions about releasing, deploying, accepting, or improving the software product.
• Gaining confidence about the level of quality of the software: Testing is the process of gaining confidence that the software product meets its requirements and expectations and provides value to the users and customers.
• Analyzing and removing the cause of failures: Testing is not only the process of finding defects but also the process of analyzing and removing the cause of failures that lead to defects. This objective is related to debugging, which is a development activity that involves locating, diagnosing, and fixing errors in the code or design of the software product.

You can find more information about the objectives of testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 1, Section 1.2.

Test metrics are quantitative measures that are used to monitor, control, and improve the test process and its outcomes. Test metrics can be collected at different levels of testing (test case, test suite, test project, etc.) and can be used for different purposes (planning, estimation, execution, evaluation, etc.). Some examples of common test metrics are:

• Percentage of work done in test environment creation: This metric indicates how much effort has been spent on setting up and maintaining the test environment, which includes hardware, software, network, data, tools, etc., that are required for conducting the test activities.
• Number of test cases run: This metric indicates how many test cases have been executed during a given period or phase of testing.
• Deviation from test milestone dates: This metric indicates how much delay or ahead of schedule the test activities are compared to the planned dates.
• Defect density: This metric indicates how many defects have been found per unit of size or functionality of the system under test.

Average number of expected defects per requirement is not a common test metric because it is not easy to estimate or measure how many defects are likely to be found for each requirement. Moreover, this metric does not provide useful information for improving the test process or evaluating the test results. You can find more information about test metrics in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 5, Section 5.41.

Risk-based testing is an approach to testing that prioritizes and focuses on testing activities based on the level of risk associated with each feature or function of the system under test. Risk-based testing aims to optimize the use of time, resources, and techniques for testing by identifying and addressing the most critical and likely sources of failure or harm in the system under test. Some examples of typical risk-based testing activities are:

• Brainstorming sessions are held with a wide variety of stakeholders to identify possible failures in the system: This activity is part of the risk identification process, which involves gathering information and opinions from different perspectives and sources to discover potential risks in the system under test.
• Tests are prioritized to ensure that those associated with critical parts of the system are executed earlier: This activity is part of the risk analysis and evaluation process, which involves assessing the probability and impact of each risk and ranking them according to their severity and importance.
• The focus of testing is shifted to an area in the system where tests find more defects than expected: This activity is part of the risk mitigation and monitoring process, which involves taking actions to reduce or eliminate the risks and tracking their status and progress.

The evaluation of a risk-management tool to decide which tool to use for future projects is not an example of a typical risk-based testing activity because it is not directly related to testing the system under test based on its risks. Rather, it is an example of a tool selection or evaluation activity, which involves comparing and choosing a tool that can support or enhance the testing process based on criteria such as functionality, usability, reliability, compatibility, cost, etc. You can find more information about risk-based testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 3, Section 3.4.

Confirmation testing, also known as re-testing, is the process of testing a defect that has been fixed to verify that it has been resolved and does not affect other parts of the system. Confirmation testing is usually done by the same tester who reported the defect and using the same test case that revealed the defect. You can find more information about confirmation testing in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 3, Section 3.21.

The V-model is a development life cycle model that shows the relationship between each phase of development and its corresponding phase of testing. In this model, each level of testing (unit testing, integration testing, system testing, acceptance testing) has a corresponding level of development (component design, component integration, system design, requirements analysis). The model also shows that testing activities should start as early as possible in the development process and that each level of testing should be planned and designed in parallel with its corresponding level of development. Therefore, one of the roles of a tester in a software company that adopts the V-model is to coordinate the test strategy with the project managers who are responsible for planning and managing each phase of development. This role involves defining the scope, objectives, approach, resources, schedule, risks, and deliverables of each level of testing in alignment with the development plan and the project requirements. You can find more information about the V-model and test planning in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 22.

The term ‘Pesticide paradox’ refers to the phenomenon where the effectiveness of test cases that are repeated and focused on the same scenarios decreases over time because they tend to find the same defects or no defects at all. This is because the system under test becomes more resistant or immune to the existing test cases, just like pests become more resistant or immune to pesticides over time. To overcome the pesticide paradox, test cases should be regularly reviewed and updated to cover new or changed requirements, scenarios, risks, or defects. Test cases should also be designed to cover different aspects and perspectives of the system under test, such as functionality, usability, performance, security, etc. You can find more information about the pesticide paradox in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 4, Section 4.11.

 System integration testing and acceptance testing are two different levels of testing that have different objectives and stakeholders. System integration testing is the process of testing the interactions and interfaces between different components or systems that form a larger system. System integration testing verifies that the system meets its functional and non-functional requirements and works as expected in its intended environment. System integration testing is usually done by testers or developers who have access to the system architecture and design specifications. Acceptance testing is the process of testing the system by the end users or customers to determine if it satisfies their needs and expectations and is ready for deployment or delivery. Acceptance testing verifies that the system complies with the user requirements and business processes and provides value to the stakeholders. Acceptance testing is usually done by users or customers who have access to the user requirements and business scenarios. You can find more information about system integration testing and acceptance testing in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 2, Sections 2.2 and 2.31.

The statement that does not describe how testing contributes to higher quality is “The testing of software demonstrates the absence of defects”. This statement is false because testing cannot prove that a software system is defect-free or has a certain level of quality because there might be some untested inputs or outputs that could reveal defects or failures. Testing can only provide information about the quality and risk level of a software system based on the observed behavior and results under certain conditions and assumptions. The other statements describe how testing contributes to higher quality by:

• Performing a review of the requirement specifications before implementing the system can enhance quality: This statement is true because reviewing the requirement specifications can help identify and prevent defects, ambiguities, inconsistencies, or incompleteness in the requirements before they are implemented in the system, which can save time and effort and improve customer satisfaction.
• Properly designed tests that pass reduce the level of risk in a system: This statement is true because passing tests can increase confidence that the system meets its requirements and expectations and provides value to the users and customers. Passing tests can also reduce the probability or impact of failures or defects in the system that could cause harm or loss.
• Software testing identifies defects, which can be used to improve development activities: This statement is true because identifying defects can help analyze and remove their causes and prevent them from recurring in future development activities. Identifying defects can also help improve development processes, methods, standards, tools, techniques, etc., by providing feedback and lessons learned.

You can find more information about how testing contributes to higher quality in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 1.

Use case testing is a specification-based test technique that is based on the use cases or scenarios that describe how users interact with the system under test. Use case testing aims to find defects in the process flow or functionality of the system under test by verifying that it behaves as expected according to the use cases or scenarios. Use case testing does not require any knowledge of the data flow or structure of the system under test; it only focuses on what the system does rather than how it does it. Use case testing can be done by professional testers or real users, depending on the level and purpose of testing. Use case testing can also be designed by customers or end users, developers, testers, analysts, or anyone who has access to the use case specifications or user requirements. You can find more information about use case testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

Beta testing is a type of acceptance testing that is normally performed by customers or potential customers at their own locations. Beta testing is done after the software product has passed the internal testing and quality assurance processes and is ready for release or deployment. Beta testing allows the customers or users to evaluate the software product in their real environment and provide feedback and suggestions for improvement. Beta testing can also help identify defects, compatibility issues, usability problems, or performance bottlenecks that might not have been detected during the internal testing. You can find more information about beta testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 2, Section 2.3.

A requirements management tool may be considered as a test support tool because it can help support or enhance some aspects of testing activities or processes. A requirements management tool is a tool that allows users to manage and trace the requirements of a software system. A requirements management tool can help support or enhance testing activities or processes by:

• Providing a clear and consistent definition of what needs to be tested based on user needs and expectations
• Enabling traceability between requirements and test cases to ensure adequate and complete test coverage
• Supporting change management and impact analysis by identifying and tracking changes in requirements and their effects on testing activities and results

Test estimation is the process of predicting the effort, time, and resources required for testing a software system. Test estimation depends on several factors that influence the scope, complexity, and quality of testing. Some of these factors are:

• Characteristics of the product: This factor indicates how difficult or challenging it is to test the software system based on its size, functionality, reliability, usability, performance, security, etc.
• Characteristics of the development process: This factor indicates how well or poorly the software system is developed based on the development methodology, standards, tools, techniques, etc.
• Characteristics of the test process: This factor indicates how effective or efficient the testing process is based on the test strategy, plan, design, execution, evaluation, etc.
• Characteristics of the test team: This factor indicates how skilled or experienced the test team is based on their knowledge, competence, motivation, communication, collaboration, etc.

The outcome of testing of previous test cycle is not a factor on which test estimation is dependent upon because it does not affect the effort, time, or resources required for testing the current test cycle. Rather, it is an outcome or consequence of test estimation that can provide feedback and lessons learned for improving future test estimations. You can find more information about test estimation in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 22.

The extent of testing required for a software product or feature depends on several factors that influence the level of quality and risk involved in delivering or deploying it. Some of these factors are:

• Budget to do testing: This factor indicates how much money is available or allocated for conducting the test activities, which affects the scope, depth, duration, and resources of testing.
• Time available to do testing: This factor indicates how much time is available or allocated for conducting the test activities, which affects the schedule, frequency, speed, and coverage of testing.
• Level of risk of the product or feature: This factor indicates how much impact or harm a failure or defect in the product or feature can cause to the users, customers, stakeholders, or environment, which affects the priority, intensity, complexity, and rigor of testing.
• Complexity of the product or feature: This factor indicates how difficult or challenging it is to understand, design, implement, or maintain the product or feature, which affects the effort, skill, technique, and tool required for testing.

A particular tester involved in testing is not a deciding factor in determining the extent of testing required because it does not affect the quality or risk level of the product or feature being tested. Rather, it is an outcome or consequence of deciding how much testing is needed based on other factors such as budget, time, risk, and complexity. You can find more information about determining the extent of testing in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 2, Section 2.12.

Regression testing is a type of testing that is performed after a software system has been changed or modified to verify that the changes have not introduced any new defects or adversely affected the existing functionality of the system. Regression testing can be performed when the software system undergoes different types of changes, such as:

• Corrective changes: Changes that fix defects or errors in the software system
• Adaptive changes: Changes that adapt the software system to new platforms or environments
• Perfective changes: Changes that improve the performance or usability of the software system
• Preventive changes: Changes that avoid potential problems or issues in the software system

In this case, the software system was re-deployed because the backend database was changed from one vendor to another, which is an example of an adaptive change. Therefore, the test manager decided to perform some functional tests on the re-deployed system to ensure that the change did not affect the functionality of the system. This is an example of regression testing.

The other types of testing mentioned in the question are not relevant for this scenario. For example:

• Non-functional testing: This type of testing verifies the non-functional aspects of the software system, such as reliability, performance, security, usability, etc.
• Structural testing: This type of testing verifies the internal structure or implementation of the software system, such as code, architecture, design, etc.
• Unit testing: This type of testing verifies individual components or units of software in isolation from other components or systems.

You can find more information about regression testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 2, Section 2.4.

Statement testing is part of structure-based testing, which is a type of testing that verifies the internal structure or implementation of a software system, such as code, architecture, design, etc. Statement testing is a structure-based test technique that involves testing every statement in the code at least once to ensure that there are no syntax errors, logical errors, or hidden defects in the code. Statement testing requires some knowledge of the internal structure or implementation of the software system; it focuses on how the system does what it does rather than what it does.

The other types of testing mentioned in the question are not related to statement testing because they do not verify the internal structure or implementation of a software system. For example:

• A. Experience-based testing: This type of testing relies on the skills, knowledge, intuition, and creativity of testers to design and execute test cases based on their experience with similar systems or situations.
• B. Decision testing: This type of testing verifies every decision point in the code by testing all possible outcomes or branches of each decision point to ensure that there are no logical errors or hidden defects in the code.
• C. Specification-based testing: This type of testing verifies the external behavior or functionality of a software system based on its requirements, specifications, design documents, or other sources of information.

You can find more information about statement testing and structure-based testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.3.

The requirement given in the image specifies an additional fee of $3 that is charged during the weekend, with some exceptions and discounts based on the age of the visitors. To test this requirement, we can use boundary value analysis, which is a specification-based test technique that involves testing the values at or near the boundaries of an equivalence partition. An equivalence partition is a set of values that are expected to be treated in the same way by the system under test. For example, based on the requirement, we can identify the following equivalence partitions for the input age:

• EP1: Age < 0 (invalid)
• EP2: Age = 0 (valid, no charge)
• EP3: 0 < Age < 7 (valid, no charge)
• EP4: Age = 7 (valid, 20% discount)
• EP5: 7 < Age < 13 (valid, 20% discount)
• EP6: Age = 13 (valid, 20% discount)
• EP7: 13 < Age < 65 (valid, full charge)
• EP8: Age = 65 (valid, 50% discount)
• EP9: Age > 65 (valid, 50% discount)

The boundary values for each equivalence partition are the values at or near the edges of the partition. For example, the boundary values for EP3 are 1 and 6. The boundary values for EP4 are 6 and 7. The boundary values for EP5 are 7 and 12. And so on.

To test this requirement using boundary value analysis, we need to select one value from each boundary and test it with different combinations of weekend and weekday. For example, we can select the following values:

• BV1: Age = -1 (from EP1)
• BV2: Age = 0 (from EP2 and EP3)
• BV3: Age = 6 (from EP3 and EP4)
• BV4: Age = 7 (from EP4 and EP5)
• BV5: Age = 12 (from EP5 and EP6)
• BV6: Age = 13 (from EP6 and EP7)
• BV7: Age = 64 (from EP7 and EP8)
• BV8: Age = 65 (from EP8 and EP9)
• BV9: Age = 66 (from EP9)

We can then create test cases using these values and different combinations of weekend and weekday. For example:

• TC1: Age = -1, Weekend = Yes -> Invalid input
• TC2: Age = -1, Weekend = No -> Invalid input
• TC3: Age = 0, Weekend = Yes -> No charge
• TC4: Age = 0, Weekend = No -> No charge
• TC5: Age = 6, Weekend = Yes -> No charge
• TC6: Age = 6, Weekend = No -> No charge
• TC7: Age = 7, Weekend = Yes -> $2.40 ($3 - 20% discount)
• TC8: Age = 7, Weekend = No -> No charge
• TC9: Age = 12, Weekend = Yes -> $2.40 ($3 - 20% discount)
• TC10: Age = 12, Weekend = No -> No charge
• TC11: Age = 13, Weekend = Yes -> $2.40 ($3 - 20% discount)
• TC12: Age = 13, Weekend = No -> No charge
• TC13: Age = 64, Weekend = Yes -> $3
• TC14: Age = 64, Weekend = No -> No charge
• TC15: Age = 65, Weekend = Yes -> $1.50 ($3 - 50% discount)
• TC16: Age = 65, Weekend = No -> No charge
• TC17: Age = 66, Weekend = Yes -> $1.50 ($3 - 50% discount)
• TC18: Age =

66, Weekend = No -> No charge

Therefore, we need a minimum of 18 valid test cases to achieve 100% boundary value coverage based on input age.

$3.01 is not a valid output boundary value because it is not a possible output value based on the requirement. The output values can only be $0, $1.50, $2.40, or $3 depending on the input age and weekend status.

You can find more information about boundary value analysis in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.2.

UAT stands for user acceptance testing, which is a type of testing that verifies that the software product meets the acceptance criteria and expectations of the end users or customers1. A UAT specification is a document that defines the scope, objectives, approach, and criteria for UAT1. Testers should be involved in reviewing a UAT specification at any time before UAT begins, as this can help to ensure that the UAT specification is clear, complete, consistent, testable, and aligned with the user requirements1. Testers can also provide feedback and suggestions to improve the UAT specification and avoid potential issues or conflicts during UAT execution1. Therefore, testers should be involved in reviewing a UAT specification at any time before UAT begins.

This is the definition of a data driven approach to test automation design, which allows for reusability and maintainability of test scripts. Option A describes a keyword driven approach, which uses action words to describe the test steps and data. Option B is not related to test automation design, but rather to performance testing. Option C is also not related to test automation design, but rather to a testing technique.

Decision testing is a white box (structure-based) test case design technique1. White box (structure-based) test case design techniques are techniques that use the structure or logic of the source code as a test basis to derive test cases and measure test coverage1. Decision testing is a technique that uses decisions (or branches) in the source code as a test basis to measure the coverage achieved by a test suite1. A decision (or branch) is a point in the source code where the control flow can take two or more alternative paths based on a condition1. Decision testing requires every decision (or branch) in the source code to take both true and false outcomes at least once by a test suite1. Therefore, decision testing is a white box (structure-based) test case design technique.

These are examples of exit criteria, which are the conditions that must be met before testing can be completed. Exit criteria may also include test coverage measures, residual risk assessment, or stakeholder approval. The other options are not exit criteria, but rather test planning activities.

To apply to the RAD development model. Metrics are quantitative measures that can be used to monitor, control, and improve the test process and the quality of the system. Metrics can be used for various purposes, such as to identify the percentage of work done in test environment preparation or test case preparation, to measure whether dates of test milestones were met, to compare actual results with expected results, to evaluate the effectiveness and efficiency of testing, etc. However, metrics are not specific to any development model, such as RAD (Rapid Application Development), and can be applied to any type of software development project. A detailed explanation of metrics can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 103-105.

Decision coverage is a structure-based test technique that involves testing every decision point in the code by testing all possible outcomes or branches of each decision point. Decision coverage requires some knowledge of the internal structure or implementation of the software system; it focuses on how the system does what it does rather than what it does.

The pseudo code given in the question has one decision point at line 4, where the value of Gender is compared to ‘female’. This decision point has two possible outcomes or branches:

• True branch: If Gender = ‘female’, then print “Ms” at line 5.
• False branch: If Gender != ‘female’, then print “Mr” at line 7.

To achieve 100 per cent decision coverage, we need to test both outcomes or branches of the decision point at least once. Therefore, we need two test cases that cover both scenarios:

• TC1: Gender = ‘female’ -> Print “Dear Ms”
• TC2: Gender = ‘male’ -> Print “Dear Mr”

The other options are not correct because they do not provide enough or too many test cases to achieve 100 per cent decision coverage. For example:

• A. 1: This option is not enough because it only provides one test case that covers one outcome or branch of the decision point, but not the other.
• C. 3: This option is too many because it provides three test cases that cover both outcomes or branches of the decision point, but one of them is redundant or unnecessary.
• D. 4: This option is too many because it provides four test cases that cover both outcomes or branches of the decision point, but two of them are redundant or unnecessary.

You can find more information about decision coverage and structure-based testing in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.3.

 Test objectives are specific goals or targets that define what testing activities should achieve or accomplish1. Test objectives for systems testing of a safety critical system include completion of all outstanding defect correction. Regression testing is required following defect correction at all test levels. Therefore, to determine whether this test objective has been met, two metrics that would be most suitable are:

• Regression tests run and passed in systems testing: This metric measures how many regression tests have been executed and passed in systems testing1. Regression testing is a type of testing that verifies that previously tested software still performs correctly after changes or defect corrections1. This metric can indicate whether all outstanding defect corrections have been completed and verified in systems testing.
• Incidents raised and closed at all levels of testing: This metric measures how many incidents have been reported and resolved at all levels of testing1. An incident is any event occurring during testing that requires investigation1. This metric can indicate whether all defects have been identified and corrected at all levels of testing.

Static analysis is a technique to find defects in software source code and software models, performed without executing code. Static analysis can be done manually or automatically using tools that examine the code or design of a software system without running it. Static analysis can help identify and prevent defects, measure complexity, check compliance, or improve quality.

The other statements are not correct definitions of static analysis because they describe different concepts related to testing. For example:

• A. The decision between using white or black box test techniques: This statement describes a test strategy, which is an approach or method for designing and executing test cases based on various factors, such as scope, objectives, risks, resources, etc.
• B. Executing software to validate the most common path through the code: This statement describes dynamic testing, which is a technique to find defects in software by executing it under various conditions and inputs and comparing the actual results with the expected results.
• D. It is a testing technique used during system testing: This statement describes a test level, which is a group of test activities that are organized and managed together based on some criteria, such as objectives, scope, target audience, etc.

You can find more information about static analysis in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 6, Section 6.3.

Testing can demonstrate that there are defects in the software, by finding and reporting them. Testing cannot demonstrate that there are no defects, because it is impossible to test all possible scenarios and inputs. Testing cannot demonstrate that the software is correct, because correctness is a subjective and relative concept that depends on the expectations and requirements of the stakeholders. Testing cannot demonstrate that there are no hidden defects in the software, because hidden defects are those that are not detected by testing or other quality assurance activities.

Boundary Value Analysis is a black-box testing technique that is used to test the boundaries or limits of input or output values for a given system or component. Boundary Value Analysis helps to identify errors at the edges of an input or output domain. For example, in a system designed to work out the employee tax to be paid, there are four boundaries for the salary input: $4,000 (lower boundary for tax free), $5,500 (upper boundary for tax free and lower boundary for 10% tax), $34,000 (upper boundary for 10% tax and lower boundary for 22% tax), and any value above $34,000 (upper boundary for 22% tax and lower boundary for 40% tax). A valid Boundary Value Analysis test case would test one value below, on, and above each boundary. For example, $33,501 is a valid test case because it is one value above the boundary of $34,000. A detailed explanation of Boundary Value Analysis can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 38-41.

Testing support tools are software tools that assist testers in performing testing activities, such as test management, test design, test execution, test evaluation, and defect management1. According to the ISTQB syllabus, some typical targets of testing support tools are to automate activities that require significant resources when done manually, automate activities that cannot be executed manually, and automate repetitive tasks1. Automating repetitive inspections is not a typical target of testing support tools, as inspections are static testing techniques that involve human review and analysis of software artifacts1.

The minimum number of test cases required to guarantee both 100% statement coverage and 100% decision coverage is 2. Statement coverage means that every statement in the code is executed at least once by the test cases. Decision coverage means that every possible outcome of each decision (such as if-else statements) is executed at least once by the test cases. To achieve both statement and decision coverage, we need to test two scenarios: one where X > Y and one where X <= Y. This will ensure that all statements and decisions are covered by the test cases. A detailed explanation of statement and decision coverage can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 61-671.

A testing design technique based in the system requirements. Decision table testing is a black-box testing technique that is used to test complex business rules or logic that involve multiple conditions and actions. Decision table testing uses a tabular format to represent all possible combinations of inputs (conditions) and outputs (actions) for a given decision. Decision table testing helps to ensure that all scenarios are covered and tested. A detailed explanation of decision table testing can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 47-511.

The statement that best defines static techniques is D. Manual examination and automated analysis of code or project documentation. Static techniques are techniques that analyze the code or other software artifacts (such as requirements, specifications, designs, models, test cases, etc.) without executing them, and provide information about their quality, defects, complexity, maintainability, etc. Static techniques can be performed manually or automatically by using tools or methods such as reviews, inspections, walkthroughs, checklists, standards, guidelines, static analysis tools, code metrics tools, etc. Static techniques can help to improve the quality and consistency of code or other software artifacts throughout the software development life cycle and reduce the cost and effort of testing and debugging. A detailed explanation of static techniques can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 27-34.

 The other details that should be included in the incident report when it is first submitted are B. Status of the incident, degree of impact, Test Case Number. These details are important to provide information about the current state of the incident, the severity of its effect on the system or user, and the test case that detected the incident. Other details, such as suggested solution, priority, history, related defects, expected fix time, line of code, etc., can be added later during the incident management process. A detailed explanation of incident report can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 99-1001.

The process that ensures that all items of testware are identified, version controlled, tracked for changes, so that traceability can be maintained throughout the test process is D. Configuration management process. Configuration management is a process that establishes and maintains the integrity and consistency of all items of testware throughout the test process. Configuration management involves identifying, storing, controlling, tracking, and auditing all items of testware (such as test plans, test cases, test scripts, test data, test results, etc.) and their versions and changes. Configuration management helps to ensure that only authorized and approved items of testware are used for testing and that traceability can be maintained between them. A detailed explanation of configuration management can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 101-1021.

Coverage of code, schedule, estimates of defect density. Exit criteria are the conditions that must be met before testing can be completed and the system can be released. Exit criteria can be based on factors such as coverage of code or requirements, schedule or budget constraints, estimates of defect density or severity, etc. Exit criteria help to determine when to stop testing and evaluate the quality of the system. A detailed explanation of exit criteria can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 15-161.

Finding defects, gaining confidence about the level of quality and providing information, and preventing defects are all valid test objectives according to the ISTQB Foundation Level syllabus. Debugging the code is not a test objective, because debugging is the process of finding and fixing defects, which is done by developers, not testers3

A potential infinite loop is a type of defect that can be typically identified using static analysis by tools1. Static analysis is a technique that examines the source code or other software artifacts without executing them, and can detect defects, vulnerabilities, code smells, and deviations from standards early in the development process1. Static analysis tools are software tools that automate the static analysis technique and provide various features and functionalities to support it1. Static analysis tools can identify a potential infinite loop by analyzing the control flow and data flow of the source code and checking for conditions or statements that may cause an endless repetition or iteration1. A potential infinite loop can cause serious problems in software performance, functionality, reliability, and security1. Therefore, a potential infinite loop is a type of defect that can be typically identified using static analysis by tools.

 Equivalence partitioning is a technique that divides the input domain of a system into partitions or classes that are expected to behave similarly or produce similar outputs2. A test case can cover one value from each partition, as it is assumed that all values in the same partition are equivalent for testing purposes2. In this question, the groups of numbers fall into different equivalence classes based on the amount of customs duty to be paid, as shown below:

Group

Equivalence Classes

$20,000 $20,001 $30,001

No duty (up to $2,000), 10% duty ($2,001-$10,000), 12% duty ($10,001-$30,000), 17% duty (above $30,000)

$2,000 $2,001 $10,000

No duty (up to $2,000), 10% duty ($2,001-$10,000), 12% duty ($10,001-$30,000)

$2,000 $8,000 $20,000

No duty (up to $2,000), 10% duty ($2,001-$10,000), 12% duty ($10,001-$30,000)

$1,500 $2,000 $10,000

No duty (up to $2,000), 10% duty ($2,001-$10,000)

Test planning and control, Test analysis and design, Test implementation and execution, Evaluating exit criteria and reporting, Test closure activities are the phases of the ISTQB fundamental test process. The fundamental test process is a generic model that describes the basic activities and tasks involved in testing software systems. defines these phases as follows:

Test planning and control: This phase involves defining test objectives, scope, strategy, resources, schedule, risks, metrics etc., as well as monitoring and controlling test activities throughout the test process.

Test analysis and design: This phase involves reviewing test basis such as requirements specifications or user stories , identifying test conditions based on analysis of test items , specifications , behavior and structure of software , designing high-level test cases based on test conditions and designing techniques , evaluating testability of requirements and system under test , defining exit criteria .

Test implementation and execution: This phase involves developing and prioritizing test cases , creating test data and writing test procedures , checking test environment has been set up correctly , executing test cases

Explanation of Correct Answer: Decision table testing is a test design technique that can be used for effectively testing system requirements consisting of logical conditions. Decision table testing is based on the idea that the system behavior can be represented by a table, where each column corresponds to a possible combination of inputs and each row corresponds to the expected outputs for that combination. Decision table testing helps to identify and cover all possible scenarios and outcomes for a given requirement12.

References: 1: Certified Tester Foundation Level Syllabus, Version 2018 v3.1.1, Section 4.3.2 2: A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 4, Section 4.3.2

The statement that environmental conditions only affect the hardware - not the software is not a good explanation why software failures can be caused by environmental conditions. Environmental conditions can affect both the hardware and the software, as they can influence the performance, reliability, and functionality of the system. For example, factors like magnetism, radiation, pollution, heat, humidity, vibration, etc. can affect electronic devices and the embedded software that runs on them. Software failures caused by environmental conditions can have serious consequences, especially for safety-critical systems. References: Certified Tester Foundation Level Syllabus, Section 1.2.2

Product risk analysis is an approach to testing that aims to reduce the level of product risks and inform stakeholders of their status, starting in the initial stages of a project1. It involves the identification of product risks and the use of risk levels to guide the test process1. Product risks are uncertain situations that can affect the quality or value of the software product2. One of the factors that can influence the testing approach is the test design technique to be applied3. Test design techniques are methods to derive and select test cases based on the test objectives, test conditions, and test basis2. Decision table testing is a test design technique that is suitable for testing complex business rules that have logical conditions and outcomes2. Therefore, if the product risk analysis identifies that the complex business rules could result in costly failures, then decision table testing will be used for test case design to cover all the possible combinations of conditions and outcomes2.

The other options are not examples of how product risk analysis can influence the testing approach, because they are either not related to product risks or not based on risk levels. They are:

• Performance failures were much lower than expected, so more test analysis will be conducted in this area (B). This is not related to product risk analysis, but to test monitoring and control, which is the process of comparing actual progress against the plan and reporting the status2. Test analysis is the activity of analyzing the test basis and defining test objectives2. If the performance failures were much lower than expected, then more test execution or evaluation might be needed, not more test analysis.
• There is a lack of automation skills in the test team, so training for the automation tool will be rolled out ©. This is not related to product risk analysis, but to test management, which is the process of planning, monitoring, and controlling the test activities and resources2. Test automation is the use of software to perform or support test activities2. The lack of automation skills in the test team is a project risk, not a product risk, and it should be addressed by providing adequate training, tools, and resources for the test team2.
• There are no product risks recorded around security, so security testing will be given priority as a contingency measure (D). This is not based on risk levels, but on the absence of risk identification, which is a poor practice in product risk analysis. Security testing is a type of testing that determines whether the software protects data and maintains functionality as intended2. Product risk analysis should identify the potential security risks and assign them appropriate risk levels based on their probability and impact1. Security testing should be prioritized based on the risk levels, not on the lack of risk identification, which could lead to overlooking or underestimating the security risks1.

References:

• ISTQB Foundation Level 2018 syllabus
• Risk in Software Testing
• Risk-Based Testing
• Test Approach

Providing developers with information to isolate the failure is the incident report objective that this excerpt satisfies. The excerpt provides the name and location of the test file that was used to recreate the failure, which can help developers to reproduce and debug the failure in their own environment. defines this objective as follows:

One of the objectives of an incident report is to provide developers with information to isolate the failure. This means providing enough details and evidence for developers to understand what caused the failure and how to fix it. This may include information such as:

• Steps to reproduce: A sequence of steps that can be followed to recreate the failure.
• Test data: The inputs that were used to execute the test case that caused the failure.
• Test environment: The configuration and settings of the hardware and software that were used to execute the test case that caused the failure.
• Attachments: Any screenshots, logs, files, or other artifacts that can help to demonstrate or explain the failure.

B, C, and D are incorrect answers. Providing ideas for test process improvement (B) is not an incident report objective that this excerpt satisfies, as it does not provide any suggestions or feedback on how to improve the test process or prevent similar failures in the future. Not belonging in an incident report © is not true, as this excerpt belongs in an incident report as part of the incident details section. Providing test leaders with information to report test progress (D) is not an incident report objective that this excerpt satisfies, as it does not provide any metrics or indicators on how much testing has been done or how many failures have been found.

The software not being able to meet the desired response time is an example of a failure. A failure is an event in which a component or system does not perform a required function within specified limits. A failure is observable by end users or testers as a deviation from expected results. defines a failure as follows:

Failure: Deviation of the component or system from its expected delivery, service or result.

B, C, and D are incorrect answers. The software not being able to meet the desired response time is not an example of a defect (B), an error ©, or not a defect (D). A defect is a flaw in a component or system that can cause it to fail to perform its required function. An error is a human action that produces an incorrect result. Not a defect is a term used to describe an incident report that is rejected or closed as invalid or out of scope. defines these terms as follows:

Defect: A flaw in a component or system that can cause the component or system to fail to perform its required function.

Error: A human action that produces an incorrect result.

Not a defect: An incident report status indicating that there is no defect in relation to this incident report.

The introduction of a test management tool does not represent one of the three triggers for maintenance testing an operational system, because it does not affect the functionality or performance of the system itself. Maintenance testing is triggered by system modification (such as corrective, adaptive, perfective or preventive changes), data migration (such as moving data from one platform or format to another), or system retirement (such as decommissioning or replacing an old system)1 .

According to the syllabus, a test summary report is a document that summarizes the results and activities of a completed test level. It typically includes information such as test objectives, test items, test environment, test cases executed, defects found, incidents raised, and lessons learned. The answer C is incorrect because it would not typically be covered in a test summary report. The economic benefit of continuing testing beyond the planned date is not a relevant information for a completed test level, as it is more related to project management decisions. The other answers are correct because they are examples of information that would typically be covered in a test summary report.

References: Certified Tester Foundation Level Syllabus, Section 5.4.1, page 62-63.

2400, 1000, 2301 are test case inputs that each fall into a different equivalence partition1. Equivalence partitioning is a black box test design technique that divides the input domain of a system into partitions of equivalent data2. Each partition should contain data that is expected to be treated the same by the system2. Therefore, only one test case input from each partition is needed to test the system’s behaviour2. In this question, the input domain of the system is the time of travel, which can be divided into three partitions based on the fare rules:

• Peak-time tariff: This partition contains all the times between 0600 and 1000 (inclusive), which are subject to a higher fare.
• Off-peak tariff: This partition contains all the times between 1001 and 2259 (inclusive), which are subject to a lower fare.
• No service: This partition contains all the times between 2300 and 0559 (inclusive), which are not valid for travel.

Therefore, to test the system’s behaviour for each partition, we need to choose one test case input from each partition. Among the options given in this question, only D contains one test case input from each partition. 2400 belongs to the no service partition, 1000 belongs to the peak-time tariff partition, and 2301 belongs to the off-peak tariff partition. Therefore, D is the correct answer.

b & c are debugging activities, because they involve locating the cause of failure and fixing the defect in the software . Debugging is the process of finding and removing the causes of software failures . The other options are not debugging activities, but rather testing activities. Option A is a testing activity, because it involves identifying a failure in the software by comparing the expected and actual results . Option D is a testing activity, because it involves checking the fix has resolved the failure by re-testing the software .

 According to the syllabus, there are two main approaches for estimating test effort: metrics-based and expert-based. The metrics-based approach uses metrics from previous similar projects or industry data to calculate the test effort based on the size and complexity of the software under test. The expert-based approach relies on the experience and judgment of the owners of the testing tasks or subject matter experts who provide their estimates based on their knowledge of the software under test. The answer B is correct because it accurately describes the expert-based approach. The other answers are incorrect because they either confuse the metrics-based and expert-based approaches or describe them incorrectly.

References: Certified Tester Foundation Level Syllabus, Section 2.3.1, page 24-25.

A key difference between a peer review of code and static analysis of code using a tool is that static analysis targets the code technically whereas peer review is applicable to further aspects. Static analysis focuses on the technical aspects of the code, such as syntax, logic, complexity, quality, security, etc. Peer review can also address these aspects, but it can also consider other aspects, such as readability, maintainability, usability, functionality, etc. Peer review can also provide feedback, suggestions, or opinions from different perspectives or expertise levels. compares these two techniques as follows:

Static analysis tools are software tools that examine (analyse) source code without executing it. They are used by developers as part of their development environment for checking their code against coding standards (rules), finding syntax errors etc.

Peer reviews are manual checking activities where work products such as requirements specifications or code are examined by colleagues (peers) for defects.

A, B, and C are incorrect answers. A peer review does not find defects while static analysis finds failures (A), as both techniques can find defects but not failures. Failures are observed at runtime when executing the code. Peer reviews cannot find missing requirements whereas static analysis can (B), as both techniques cannot find missing requirements but only check conformance to existing requirements. Missing requirements can be found by other techniques such as elicitation or validation. A peer review finds failures while static analysis finds defects ©, as both techniques find defects but not failures. Failures are observed at runtime when executing the code.

According to the syllabus, test design is the activity of deriving and specifying test cases from test conditions to test software. Test design involves processes such as identifying test data, designing test scenarios, creating test procedures, and defining expected results. The answer A is correct because it is an example of a task most associated with the test design activity. Test data, derived from production data, is developed for use during testing. The other answers are incorrect because they are examples of tasks associated with other test activities, such as test planning (B), test implementation ©, and test monitoring and control (D).

References: Certified Tester Foundation Level Syllabus, Section 1.4.2, page 16-17.