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

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.

 it provides the highest level of transition coverage for the model. Transition coverage is a white-box test technique that focuses on the percentage of transitions that have been exercised by a test suite1. In this case, the model is a state transition diagram that shows the possible states and transitions of a sales order software. The diagram has five states: PLACED, IN PRODUCTION, SHIPPED, INVOICED, and CANCELLED. The diagram has nine transitions: PLACED to IN PRODUCTION, PLACED to CANCELLED, IN PRODUCTION to SHIPPED, IN PRODUCTION to CANCELLED, SHIPPED to INVOICED, SHIPPED to CANCELLED, INVOICED to CANCELLED, CANCELLED to PLACED, and CANCELLED to IN PRODUCTION. Option C covers all nine transitions in the following sequence:

• IN PRODUCTION -> SHIPPED
• SHIPPED -> INVOICED
• INVOICED -> CANCELLED
• CANCELLED -> PLACED
• PLACED -> IN PRODUCTION

Option A covers only six transitions in the following sequence:

• PLACED -> CANCELLED
• CANCELLED -> PLACED
• PLACED -> IN PRODUCTION
• IN PRODUCTION -> CANCELLED

Option B covers only five transitions in the following sequence:

• PLACED -> IN PRODUCTION
• IN PRODUCTION -> SHIPPED
• SHIPPED -> CANCELLED
• CANCELLED -> PLACED

Option D covers only four transitions in the following sequence:

• IN PRODUCTION -> CANCELLED
• CANCELLED -> PLACED
• PLACED -> IN PRODUCTION

Therefore, option C is the correct answer. Options A, B, and D are incorrect, as they do not cover all the transitions in the model. References: 1, Section 4.2.2

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.

A test condition is an item or event of a component or system that can be verified by one or more test cases. A test condition can be derived from various sources of information, such as requirements, specifications, design documents, use cases, user stories, etc. A test condition can also be based on various aspects of a component or system, such as functionality, usability, performance, reliability, security, etc.

The other statements are not true about test conditions because they describe different concepts related to testing. For example:

• B. The grouping of a composite set of test cases which, when tested as a whole, reveal a positive or negative result: This statement describes a test suite, which is a collection of test cases that are intended to be executed together to achieve a specific test objective or goal.
• C. A testable component derived from business requirements: This statement describes a test basis, which is the source of information or data that provides the basis for designing and executing test cases.
• D. Applies to software testing only: This statement is false because test conditions can apply to any type of testing, not just software testing. Test conditions can also be used for testing hardware, systems, processes, etc.

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

Exhaustive testing is a technique that covers all possible combinations of inputs and preconditions2. However, it is not recommended to perform exhaustive testing, as it is usually impractical and impossible due to the large number of test cases required2. Instead, risk analysis and priorities should be used to focus testing efforts on the most important and critical aspects of the system under test2.

 These are some of the factors that should be considered to determine whether enough testing has been performed. The exit criteria define the specific goals and requirements for testing completion. The budget limits the resources and time available for testing. The product’s risk profile indicates the areas of highest priority and impact for testing. Sufficient details of the system status allow decisions on whether further testing is needed or not. The other options are not relevant factors for determining enough testing.

The testing effort required to test a software product depends on various factors, such as the size and complexity of the product, the quality of the requirements and design documents, the testability of the product, the test strategy and scope, the test environment and tools, the skills and experience of the testers, and the quality expectations and standards of the stakeholders1. Among these factors, the requirements for reliability and security in the product will most affect the testing effort required to test a software product1. Reliability and security are quality attributes that measure how well a software product performs its intended functions under specified conditions and protects itself from unauthorized access or harm1. Testing for reliability and security requires more rigorous and thorough testing techniques, such as reliability testing, security testing, penetration testing, stress testing, etc1. These techniques may require more time, resources, tools, and skills to perform effectively1. Therefore, the requirements for reliability and security in the product will most affect the testing effort required to test a software product.

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.

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.

Testing is the process of evaluating a software product by learning about it through exploration and experimentation, which includes running tests, observing outcomes, making inferences, and creating and refining test ideas. Testing has many objectives, such as finding defects, providing information, improving quality, reducing risks, etc. One of the objectives of testing is preventing defects, which means avoiding or minimizing the occurrence of defects in the software product by applying good practices and techniques throughout the software development life cycle. Preventing defects can help to save time, cost, and effort in testing and development, and improve customer satisfaction and confidence. A detailed explanation of testing objectives can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 7-8.

When an organization considers the use of testing tools, they should C. Perform analysis of the test process and then assess whether it can be supported through the introduction of tool support. Testing tools can provide many benefits to the test process, such as increased efficiency, effectiveness, consistency, quality, etc. However, testing tools also have some challenges and risks associated with them, such as cost, learning curve, compatibility, maintenance, etc. Therefore, before introducing any testing tool, an organization should analyze their current test process and identify their needs, goals, expectations, constraints, etc., and then evaluate whether a tool can support them or not. A detailed explanation of testing tools can be found in Software Testing Foundations: A Study Guide for the Certified Tester Exam, pages 193-1983.

 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.

 Likelihood of failure = 10%, potential cost of impact = $500,000. The level of risk to the project can be calculated by multiplying the likelihood of failure by the potential cost of impact. This gives us the following values for each option:

A. 1% x $1m = $10,000 B. 10% x $500,000 = $50,000 C. 20% x $150,000 = $30,000 D. 5% x $500,000 = $25,000

Metrics are quantitative measures that can be used to monitor and control various aspects of software testing processes and products1. Metrics can be used to monitor progress along with test preparation and execution by providing information about the status of testing activities, such as test planning, test design, test execution, test evaluation, defect management, etc1. Among the options given in this question, only C is a suitable metric for monitoring progress along with test preparation and execution. The failure rate in testing already completed is a metric that measures how many tests have failed out of the total number of tests executed1. This metric can indicate the quality of the software product under test and the effectiveness of the test cases1. It can also help to identify areas that need more attention or improvement in testing1. Therefore, this metric can be used to monitor progress along with test preparation and execution.

• An incident report is a document that records any event occurring during testing that requires investigation1. An incident report should contain sufficient information to enable reproduction of the incident and resolution of the defect1. According to IEEE 829 Standard for Software Test Documentation, an incident report should contain the following information:

Therefore, among the options given in this question, only D provides the best detail on an incident report. It contains a clear title, a reproducibility indicator, a description that includes both expected and actual results, a reference to the specification document, and a screen shot of the failure. The other options are either missing some important information or providing inaccurate or irrelevant information

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.

•  According to the IEEE 829 Standard for Software Test Documentation, an incident report should contain the following information:

Therefore, among the options given in this question, only (i), (iii), and (iv) are part of an incident report based on IEEE 829.

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.

Statement coverage and decision coverage are both less than 100%. Statement coverage is a criterion that requires every executable statement in the source code to be executed at least once by a test suite1. Decision coverage is a criterion that requires every decision (or branch) in the source code to take both true and false outcomes at least once by a test suite1. The flow graph below shows the logic of a program for which 100% statement coverage and 100% decision coverage is required on exit from component testing. The flow graph has 9 nodes (A, B, C, D, E, F, G, H, I) and 10 edges (1, 2, 3, 4, 5, 6, 7, 8, 9, 10). The edges represent executable statements and the nodes represent decisions or branches.

!flow graph

The following test cases have been run:

• Test Case 1 covering path A-B-C-D-E-F-G-H-I
• Test Case 2 covering path A-B-C-D-E-F-G-H
• Test Case 3 covering path A-B-C-D-E-F
• Test case 4 covering path A-B-C-D-E

To calculate the statement coverage and decision coverage achieved by these test cases, we can use the following formulas:

• Statement coverage = (Number of statements executed / Total number of statements) x 100%
• Decision coverage = (Number of decisions exercised / Total number of decisions) x 100%

In this case, the number of statements executed by the test cases is 8 (edges 1, 2, 3, 4, 5, 6, 7, and 9). The total number of statements in the flow graph is 10 (edges 1 to 10). Therefore, the statement coverage achieved by the test cases is:

• Statement coverage = (8 / 10) x 100% = 80%

The number of decisions exercised by the test cases is also 8 (nodes A, B, C, D, E, F, G, and H). The total number of decisions in the flow graph is also 10 (nodes A to J). Therefore, the decision coverage achieved by the test cases is:

• Decision coverage = (8 / 10) x 100% = 80%

Therefore, statement coverage and decision coverage are both less than 100%. To achieve 100% statement coverage and decision coverage, two more test cases are needed to cover edges 8 and 10 and nodes I and J.

• Defect 1: Missing test case for validation failure of ‘Password’ field being blank. According to checklist item C2, there must be one test case for each error path. The test basis document specifies that the ‘Password’ field must be mandatory, and that if it is blank, Error Number 13 should be displayed. However, none of the test cases cover this scenario. Therefore, a test case for this validation failure is missing and should be added.
• Defect 2: Incorrect field name in TC3. According to checklist item C3, each test case must use terminology consistent with the test basis document. The test basis document uses the term ‘User Name’ to refer to the field that identifies the user. However, TC3 uses the term ‘User Id’, which is inconsistent and confusing. Therefore, TC3 should be corrected to use the term ‘User Name’ instead of ‘User Id’.
• Defect 3: Incorrect error number in TC3. According to checklist item C3, each test case must use terminology consistent with the test basis document. The test basis document specifies that if the ‘User Name’ entered does not exist on the database, Error Number 12 should be displayed. However, TC3 states that Error Number 23 should be displayed, which is incorrect and does not match the test basis document. Therefore, TC3 should be corrected to use Error Number 12 instead of Error Number 23.

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.

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.

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.

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.

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.

The most important report improvement is A. Add an impact analysis. An impact analysis is an assessment of how the defect affects the functionality, usability, performance, reliability, security, or other aspects of the system under test. An impact analysis can help prioritize and classify the defect based on its severity and urgency. An impact analysis can also help determine the root cause and possible solutions for the defect. An impact analysis is an essential part of a defect report because it provides useful information for decision-making and improvement processes.

The other report improvements are not as important as adding an impact analysis because they do not provide as much information or value for decision-making and improvement processes. For example:

• B. Add information about which developer should fix the bug: This report improvement is not necessary because it is not part of the information that is required to describe, reproduce, and prioritize the defect. The assignment of developers to fix bugs is part of the defect management process, which involves assigning, tracking, resolving, and verifying defects.
• C. Add the time stamp when the incident happened: This report improvement is not very useful because it does not provide much information about the cause or effect of the defect. The time stamp when the incident happened is only relevant if it is related to some external factors or events that could influence the behavior or performance of the system under test.
• D. Add information about which web browser was used: This report improvement is not very relevant because it does not affect the functionality or usability of the system under test. The web browser used is only relevant if it is related to some compatibility or interoperability issues that could cause defects or failures in the system under test.

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

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.

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.

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.

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.

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.

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.

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.

Multiple condition coverage is a structure-based test technique that aims to achieve a high level of coverage by testing all possible combinations of conditions and outcomes in each decision point of the code or design of the system under test. Multiple condition coverage verifies that each condition in a decision point has an effect on the outcome and that there are no hidden defects or logical errors in the code or design. Multiple condition coverage requires some knowledge of the internal structure or implementation of the system under test; it focuses on how the system does what it does rather than what it does. Multiple condition coverage is one of the most rigorous and complex structure-based test techniques because it can generate a large number of test cases for each decision point, especially if there are many conditions involved. You can find more information about multiple condition coverage in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], Chapter 4, Section 4.3.

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.

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 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.

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.

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.

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

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.

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 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.

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.

Component testing is a part of the V-Model, which 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). Component testing is the process of testing individual components or units of software in isolation from other components or systems. Component testing verifies that the components meet their functional and non-functional requirements and work as expected in their intended environment. Component testing is usually done by developers who have access to the component design and code specifications. You can find more information about component testing and the V-Model in Software Testing Foundations: A Study Guide for the Certified Tester Exam, Chapter 22.

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.

The Test Analysis and Design activity of the test process is the activity where test conditions and test cases are identified and specified based on the test objectives and criteria. The Test Analysis and Design activity also involves identifying and preparing the necessary test data and test environment to support the test execution. Some of the tasks of the Test Analysis and Design activity are:

• Reviewing the test basis: This task involves reviewing the requirements, specifications, design documents, or other sources of information that form the basis for testing.
• Identifying test conditions: This task involves identifying what needs to be tested based on the test basis and objectives.
• Designing and prioritizing test cases: This task involves designing specific scenarios or steps to verify each test condition and assigning priorities to them based on their importance or risk level.
• Identifying necessary test data to support the test conditions and test cases: This task involves identifying what data is needed to execute each test case and how to obtain or generate it.
• Identifying and preparing the test environment: This task involves identifying what hardware, software, network, data, tools, etc., are needed to execute the test cases and how to set up and maintain them.

Measuring the percentage of prepared test cases with what was actually prepared is not a task of the Test Analysis and Design activity because it does not involve identifying or specifying anything related to testing. Rather, it is a task of the Test Monitoring and Control activity, which involves measuring and reporting the progress and status of testing against the planned activities and criteria. You can find more information about the Test Analysis and Design activity in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 31.

 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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

For the code fragment given below, one test case is required for statement coverage and two test cases are required for branch coverage. Statement coverage requires that every executable statement in the code is executed at least once. Branch coverage requires that every possible outcome of each decision point in the code is executed at least once. The following table shows how to achieve statement and branch coverage for the code fragment:

Test Case

Input

Output

Statement Coverage

Branch Coverage

1

x = 3

y = 9

S1, S2, S3

T1 = true

2

x = 5

y = 25

S1, S2

T1 = false

As shown in the table, test case 1 covers all three statements (S1, S2, S3) in the code fragment, achieving 100% statement coverage. Test case 2 covers only two statements (S1, S2) in the code fragment, but it exercises a different outcome of the decision point T1 (if x < 4), achieving 100% branch coverage.

Cost can be regarded as an exit criterion, as it is one of the factors that can influence the decision to stop testing. Spending too much money on testing will result in an unprofitable product, and having cost as an exit criterion helps avoid this. The other options are incorrect, as the financial value of product quality can be estimated, the cost of testing can be measured effectively, and having cost as an exit criterion does not necessarily constrain the testing project or help achieve the desired quality level.

References: Section 2.2.1, Section 2.2.3

A key difference between black box and white box test design techniques is that white box techniques can measure the extent of code coverage, while black box techniques cannot. Code coverage is a measure of how much of the code of a system or component has been executed by a test or a set of tests. White box techniques use software code to derive test cases that cover specific aspects of the code, such as statements, branches, paths, or data flows. White box techniques can use tools or methods to measure the code coverage achieved by the test cases and identify any gaps or redundancies. Black box techniques use functional design specifications to derive test cases that cover specific aspects of the functionality, behavior, or quality of the system or component, such as inputs, outputs, equivalence classes, boundary values, states, transitions, etc. Black box techniques do not use or access the code of the system or component, and therefore cannot measure the code coverage.

References: Certified Tester Foundation Level Syllabus, Section 4.3 and 4.4

 According to the syllabus, the choice of a particular type of software development life cycle (SDLC) model depends on various factors, such as project size, complexity, scope, budget, schedule, quality requirements, risk level, customer involvement, etc. The type of product being developed is one of the most important factors that influences the selection of an SDLC model, as different products may have different characteristics, expectations, and challenges that require different approaches to development. For example, a product that has well-defined and stable requirements may benefit from a sequential SDLC model like waterfall or V-model, while a product that has vague or changing requirements may benefit from an iterative SDLC model like incremental or agile. The answer D is correct because it best reflects the reason for selecting a particular type of SDLC model. The other answers are incorrect because they are not good reasons for selecting a particular type of SDLC model. Tester skill level with the SDLC model (A) may affect the effectiveness and efficiency of testing activities, but it should not be the primary factor for choosing an SDLC model. Testers should be able to adapt to different SDLC models depending on the project context and objectives. The project manager’s preference (B) may reflect their personal experience or opinion, but it should not be the sole factor for choosing an SDLC model. The project manager should consider various factors and consult with other stakeholders before selecting an SDLC model. The project team’s overall familiarity with the model © may affect the productivity and collaboration of the team members, but it should not be the main factor for choosing an SDLC model. The project team should be able to learn and apply different SDLC models depending on the project context and objectives.

References: Certified Tester Foundation Level Syllabus, Section 1.1.1, page 9-10.

Traceability is the ability to identify related items in documentation and software, such as requirements, design specifications, code modules, test cases, test results, etc. Traceability helps to ensure that all requirements are covered by tests, that all tests are linked to requirements, and that any changes in requirements or software can be traced to their impact on other items.

The correct answer is C, as it describes a benefit of test automation. Test automation is the use of software to control the execution of tests, the comparison of actual outcomes to predicted outcomes, the setting up of test preconditions, and other test control and test reporting functions1. Test automation can have many benefits, such as reduction in repetitive manual work1. This can improve the efficiency and effectiveness of testing by saving time, effort, and resources1. Option A is incorrect, as it does not describe a benefit of test automation, but a factor that influences the selection of test automation tools. Availability of the test automation tool vendor is a factor that affects the availability and support of the tool, which may affect the success of test automation1. Option B is incorrect, as it does not describe a benefit of test automation, but a misconception. Negligible effort to maintain the test assets generated by the tool is not true, as test automation requires regular maintenance and update of the test scripts, data, and expected results to cope with changes in the software under test1. Option D is incorrect, as it does not describe a benefit of test automation, but a drawback. More subjective assessment is not a benefit, as test automation may introduce bias and errors in the test results due to human factors such as lack of skills, knowledge, or experience1. References: 1, Section 2.10

Exploratory testing can replace black box techniques when testing time is very limited, because it is a type of experience-based technique that allows testers to design and execute tests based on their intuition, knowledge, and skills, without following a predefined test plan or test cases13. The other options are false statements about testing techniques. Option B is false, because test execution scheduling should give priority to specification-based or structure-based techniques, which are more systematic and objective than experience-based techniques13. Option C is false, because specification-based techniques cannot be used as a substitute for a poorly defined test basis, but rather require a clear and complete test basis to design effective test cases13. Option D is false, because experience-based techniques are not systematic and do not produce detailed test documentation, but rather rely on the tester’s judgement and creativity

Explanation of Correct Answer: Priority indicates the level of business importance assigned to the defect, while severity indicates the degree of impact that a defect has on the development or operation of a component or system. Urgency is not a standard term used in defect reporting, and difficulty refers to the effort required to fix the defect.

References: Section 1.4.3.2, Section 5.3.2

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.

 A variable has the wrong numeric value passed into it is the type of defect that would not be typically found by using a static analysis tool, because it is a logical or functional error that depends on the context and requirements of the software13. A static analysis tool can detect syntactic or structural errors in the code, such as missing declarations, undefined variables, unused variables, or unreachable code13. The other options represent such errors that can be typically found by using a static analysis tool. Option A is an error where a variable is defined but is then not used, which indicates a waste of memory or a possible logic flaw13. Option B is an error where a variable is used in a calculation before it is defined, which can cause unpredictable results or exceptions13. Option D is an error where a variable is used but not declared, which can cause compilation or runtime errors

 Using a keyword-driven testing approach to separate the actions and data from the tool’s script is the best approach to improve the way test automation tools are being used in your company, because it allows for more flexibility, maintainability, and reusability of automated test scripts1 . A keyword-driven testing approach uses keywords or commands to represent actions or data in the test scripts, which can be stored in external files or tables and accessed by the tool1 . The other options are not good approaches to improve the way test automation tools are being used in your company. Option A is not a good approach, because selecting and automating scripts that test new functionality to find the most defects does not consider the suitability, feasibility, and cost-effectiveness of automation1 . Option C is not a good approach, because ensuring that all data, inputs and actions are stored in the tool’s script for ease of maintenance makes the test scripts more rigid, complex, and difficult to modify1 . Option D is not a good approach, because keeping expected results separate from the automation tool to allow the testers to check the results reduces the efficiency and reliability of automation and increases the manual effort

 The three ages that would test all valid equivalence partitions and therefore test rate A, B and C are 20, 35 and 65. Equivalence partitioning is a technique to divide a set of possible inputs or outputs into classes that are expected to behave similarly or produce similar results. For each equivalence class, only one test case is required to represent the whole class. In this case, we can identify the following equivalence classes for the age of the driver:

• Valid age between 17 and 25 inclusive (rate A)
• Valid age between 26 and 50 inclusive (rate B)
• Valid age over 50 (rate C)
• Invalid age below 17
• Invalid age above 100

Therefore, three test cases are required to test all valid equivalence partitions, and any value within each class can be used as a representative value. For example, 20 for rate A, 35 for rate B, and 65 for rate C.

References: Certified Tester Foundation Level Syllabus, Section 4.4.1

The ideal number of regression test cycles is as many as time and budget allow, because regression testing is done to ensure that no new defects have been introduced by changes or fixes in the software, and that all previously fixed defects are still fixed. Therefore, more regression test cycles can increase the confidence in the software quality and reliability.

Explanation of Correct Answer: A key characteristic of informal reviews is that they are low cost, as they do not require much documentation, preparation, or follow-up. Therefore, option D is correct. Option A is incorrect, as metrics analysis is not a part of informal reviews. Option B is incorrect, as kick-off meeting is a part of formal reviews. Option C is incorrect, as individual preparation is not required for informal reviews.

References: [Certified Tester Foundation Level Syllabus], Section 3.2.1

Variables that are not used or improperly declared are defects that are more likely to be found by a static analysis tool than by other testing techniques, because they are syntactic or structural errors in the code that can be detected without executing the software13. A static analysis tool can analyse the code or design of the software under test and identify errors such as missing declarations, undefined variables, unused variables, or unreachable code13. The other options are not defects that are more likely to be found by a static analysis tool than by other testing techniques. Option A is not a defect that can be found by a static analysis tool, but rather by a requirements review or specification-based testing technique1 . Option B is not a defect that can be found by a static analysis tool, but rather by a structure-based testing technique or a coverage measurement tool1 . Option C is not a defect that can be found by a static analysis tool, but rather by a dynamic analysis tool or a monitoring tool1 .

Test control is a test management activity that involves making decisions based on information from test monitoring and test progress reporting. Test control activities include:

• Re-prioritizing tests because of time pressure
• Changing the test schedule due to availability of a test environment
• Setting entry and exit criteria for test levels or test activities
• Initiating corrective actions to resolve deviations from the test plan

Writing test suspension and resumption criteria in the test plan is not a test control activity, but rather a test planning activity. Test suspension and resumption criteria are used to define when to stop and resume testing in case of unforeseen events or issues that affect the test execution.

References: Certified Tester Foundation Level Syllabus, Section 2.4.2 and 2.4.3

According to the syllabus, traceability between the test basis and test work products is the ability to link each element of the test basis to the various test work products associated with that element, such as test conditions, test cases, test procedures, and test results. Traceability between the test basis and test work products has several benefits, such as evaluating the extent of test coverage, analyzing the impact of changes, making testing auditable, meeting IT governance criteria, improving the understandability of test reports, and providing information to assess product quality, process capability, and project progress. The answer B is incorrect because it is not a benefit of traceability between the test basis and test work products. It obscures the impact of changes. On the contrary, traceability helps to reveal the impact of changes by showing which elements of the test basis are affected by a change and which test work products need to be updated or executed accordingly. The other answers are correct because they are examples of benefits of traceability between the test basis and test work products.

References: Certified Tester Foundation Level Syllabus, Section 1.4.4, page 18-19.

The equivalence classes for the username string are based on the length of the string, not on the type of password or the error message. Therefore, option C is correct, as it divides the username string into two equivalence classes: shorter than 6 characters and equal to or longer than 6 characters. Option A is incorrect, as it does not consider the length of the username string. Option B is incorrect, as it does not specify the criteria for displaying or not displaying the error message. Option D is incorrect, as it confuses the username string with the password string.

References: Certified Tester Foundation Level Syllabus, Section 4.2.2

According to the syllabus, decision coverage is a technique that measures the percentage of decision outcomes that have been exercised by a test suite. A decision outcome is the result of evaluating a boolean expression in a control structure, such as an if statement or a switch statement. The goal of decision coverage testing is to cover and validate all the accessible source code by checking and ensuring that each branch of every possible decision point is executed at least once. The answer C is incorrect because it is not a valid use of decision coverage testing. Decision coverage testing does not check that all decisions are based on a numeric value, as there can be other types of values involved in boolean expressions, such as strings or booleans. The other answers are correct because they are valid uses of decision coverage testing. Checking that all decisions have been exercised in a single program or a business process can help to identify defects or missing functionality in the code or process logic. Checking that at least 100% decision coverage has been achieved can help to ensure that all reachable code has been executed and that 100% statement coverage has been achieved as well.

References: Certified Tester Foundation Level Syllabus, Section 4.2.3, page 42-43.

It is not allowed as organizations can’t change the test levels as these are chosen on the basis of the SDLC (software development life cycle) model. The V-model is a type of SDLC model that defines four test levels: component testing, integration testing, system testing, and acceptance testing. Each test level corresponds to a development phase in a parallel manner. Integration testing is an essential part of the V-model, as it verifies that the components work together correctly and consistently2 explains this as follows:

The V-model is a graphical representation of a systems development lifecycle. It is used to produce rigorous development lifecycle models and project management models. The V-model falls into three broad categories, the German V-Modell, a general testing model and the US government standard.

The V-model summarizes the main steps to be taken in conjunction with the corresponding deliverables within project execution and delivery. It describes software development activities from requirements specification to maintenance.

The V-Model demonstrates the relationships between each phase of the development life cycle and its associated phase of testing.

A, C, and D are incorrect answers. A implies that integration testing is not an important test level and can be dispensed with, which is not true as integration testing ensures that the system functions as a whole and meets its requirements. C implies that organizations can decide on which test levels to do depending on the context of the system under test, which is not true as test levels are determined by the chosen SDLC model and its objectives. D implies that integration testing is a very important test level and ignoring it means definite poor product quality, which is true but not relevant to why it is not allowed to do away with integration testing in a V-model.

Test implementation and execution is the stage of the Fundamental Test Process where testers write detailed steps for executing each test case (test procedures), prepare and prioritize test cases for execution, execute test cases and record results, compare actual results with expected results and report discrepancies as incidents.

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

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.

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.

The statement that component testing tests interfaces between modules and interactions of different parts of a system does not describe component testing. Component testing is the process of testing individual software components that are separately testable, such as modules, programs, objects, classes, etc. Component testing verifies the functionality and quality of the components in isolation from other components. Component testing does not test the interfaces or interactions between components, as this is done in integration testing.

References: Certified Tester Foundation Level Syllabus, Section 5.1.2

Testing the ease of modification of systems is the statement that is least likely to be true of non-functional testing. Non-functional testing is testing of the non-functional aspects of a system or software component, such as performance, usability, reliability, security, etc. Non-functional testing does not usually include testing the ease of modification of systems, as this is more related to maintainability, which is a quality attribute rather than a non-functional requirement1 defines non-functional testing as follows:

Non-functional Testing is defined as a type of Software testing to check non-functional aspects (performance, usability, reliability, etc) of a software application. It is designed to test the readiness of a system as per nonfunctional parameters which are never addressed by functional testing.

Non-functional Testing involves testing of non-functional requirements such as Load Testing, Stress Testing, Security, Volume, Recovery Testing etc. The objective of NFT testing is to ensure whether the response time of software or application is quick enough as per the business requirement.

A, B, and D are incorrect answers. Evaluating the interaction of various specified components (A), testing how the system works (B), and performing at unit, integration, system and acceptance test levels (D) are statements that are likely to be true of non-functional testing. Non-functional testing can cover the interaction of various components in terms of performance, reliability, compatibility, etc. Non-functional testing can test how the system works in terms of speed, efficiency, stability, etc. Non-functional testing can be performed at different test levels depending on the scope and objectives of the test.

Checking that at least 50% of decisions have been exercised by a test case suite is not a valid use of decision coverage, because it does not meet the minimum criterion of decision coverage, which is to exercise all possible outcomes of each decision in the software under test1 . Decision coverage is a technique that measures how much of the logic or branching of the software under test has been exercised by the test cases1 . The other options are valid uses of decision coverage. Option A is a valid use of decision coverage, because it can check that all decisions have been exercised in a single program1 . Option B is a valid use of decision coverage, because it can check that all decisions have been exercised in a business process1 . Option C is a valid use of decision coverage, because it can check that all calls from one program module to another have been made correctly1 .

100% branch coverage means 100% statement coverage, but not vice-versa. Branch coverage is a stronger criterion than statement coverage, as it requires that every possible outcome of each decision point is executed at least once. Statement coverage only requires that every executable statement is executed at least once1 explains this as follows:

Branch Coverage (also known as Decision Coverage) measures which possible branches in flow control structures are followed. Branch Coverage is a testing method, which aims to ensure that each one of the possible branch from each decision point is executed at least once and thereby ensuring that all reachable code is executed.

Statement Coverage measures the number of statements in the source code that are executed during the test. Statement Coverage is a metric, which is used to calculate and measure the number of statements in the source code which have been executed during testing.

B, C, and D are false statements. 100% statement coverage does not mean 100% branch coverage (B), as there may be some branches that are not covered by the test cases. 100% branch coverage does not mean 100% statement coverage and vice-versa ©, as branch coverage implies statement coverage but not the other way around. It is possible to achieve 100% statement coverage (D), but it may not be feasible or cost-effective for some systems.

According to the syllabus, a mindset is a set of attitudes, beliefs, and assumptions that influence how a person thinks, feels, and behaves. A mindset for test activities and a mindset for development activities are different and complementary, as they reflect different goals and perspectives of testing and development. A tester is concerned with finding defects while a developer is interested in designing solutions. This statement best describes the key difference between a mindset for test activities and a mindset for development activities. A tester’s mindset is focused on identifying and reporting problems in the software product or system, such as errors, failures, or deviations from requirements or expectations. A tester’s mindset is also characterized by professional skepticism, curiosity, creativity, and critical thinking. A developer’s mindset is focused on creating and implementing solutions for the software product or system, such as features, functions, or enhancements. A developer’s mindset is also characterized by professional optimism, confidence, logic, and analytical thinking. The other answers are incorrect because they either confuse the roles of testers and developers or use incorrect terms.

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

Test analysis and design is the activity in the fundamental test process that includes identifying necessary test data. Test data are the inputs that are used to execute the test cases and verify the expected results2 defines this activity as follows:

Test analysis and design has the following major tasks:

• Reviewing the test basis (such as requirements, risk analysis reports, design documents or code).
• Identifying test conditions based on analysis of test items, specifications, behavior and structure of the software.
• Designing high-level test cases based on test conditions and designing techniques.
• Evaluating testability of requirements and system under test.
• Defining exit criteria.

Evaluating exit criteria and reporting (A) is part of the test closure activities, where the results of testing are evaluated against the defined objectives. Test implementation and execution (B) is where the test cases are executed using the identified test data and deviations from expected results are documented. Test planning and control © is where the overall approach and resources for testing are defined and monitored.

Estimating the cost of testing is not a typical task for a test leader. Estimating the cost of testing is usually done by project managers or senior managers who have access to budgetary information and authority to allocate resources for testing activities. Test leaders may provide input or feedback on estimating the cost of testing, but they are not responsible for it3 states this as follows:

Estimating costs for test activities within a project is typically done by project managers who have overall responsibility for budgeting and resource allocation within a project. Test leaders may assist project managers in estimating costs for test activities by providing information on test effort, test environment, test tools, etc., but they do not have final authority or accountability for cost estimation.

A, B, and C are incorrect answers. Selecting the test approach (A), coordinating the test strategy (B), and preparing and acquiring test data © are typical tasks for a test leader. Selecting the test approach is part of test planning and control, which involves defining the test objectives, scope, strategy, resources, schedule, risks, metrics, etc. Coordinating the test strategy is part of test monitoring and control, which involves measuring and evaluating test progress and quality against objectives and criteria. Preparing and acquiring test data is part of test implementation and execution, which involves developing and prioritizing test cases, creating test data and writing test procedures, checking test environment has been set up correctly, executing test cases, etc.

 Logging the outcome of test execution and reporting bugs is an activity that is performed as part of the Test Implementation and Execution activity, because it involves recording and communicating any deviations from the expected results or behaviour of the software under test1 . Test Implementation and Execution is the process of running the test cases or procedures on the software under test and comparing the actual results with the expected results1 . The other options are not activities that are performed as part of the Test Implementation and Execution activity, but rather as part of other activities. Option B is an activity that is performed as part of the Test Analysis activity, because it involves evaluating the testability of the test basis and test objects to identify test conditions1 . Option C is an activity that is performed as part of the Test Closure activity, because it involves assessing if the specified exit criteria should be changed to determine when to stop testing1 . Option D is an activity that is performed as part of the Test Planning activity, because it involves selecting metrics for monitoring test execution and defect resolution to measure the progress and quality of testing1 .

The correct answer is A, as it describes error guessing. Error guessing is an experience-based test technique that involves designing tests based on experience, defect data, or common knowledge about why software fails1. Error guessing can be used to complement other more formal test techniques by focusing on areas that are more likely to contain defects1. Option B is incorrect, as error guessing does not involve building test cases based on the various experiences of developers, architects, users, and other stakeholders on project teams, but based on the tester’s own experience and knowledge1. Option C is incorrect, as error guessing is not a suitable test technique that can be used effectively in place of more formal techniques, but a supplementary technique that can be used in addition to more formal techniques1. Option D is incorrect, as error guessing is not a valid and useful white-box test technique due to its high degree of statement coverage, but an experience-based test technique that does not rely on the structure of the software1. References: 1, Section 4.2.6

 Wrong business rules are defects that cannot be found by static analysis tools, because they are logical or functional errors that depend on the context and requirements of the software13. A static analysis tool can only detect syntactic or structural errors in the code or design of the software under test, but not whether they match the intended business rules or logic13. The other options are defects that can be found by static analysis tools. Option A is a defect that can be found by a static analysis tool, because it is a structural error that causes the code to loop indefinitely without terminating13. Option C is a defect that can be found by a static analysis tool, because it is a syntactic error that causes the code to fail to compile or run13. Option D is a defect that can be found by a static analysis tool, because it is a structural error that indicates a waste of memory or a possible logic flaw

 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.

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.

Each review has clear defined objectives, the right people for the review objective are involved, and there is an emphasis on learning and process improvement are typically found to enable the review process to be successful1. A review is a type of static testing that involves the examination of software artifacts by humans to find defects, improve quality, or achieve other objectives1. A review process should have clear defined objectives that specify the purpose, scope, and expected outcomes of the review1. The right people for the review objective should be involved, such as reviewers, moderators, authors, managers, etc., who have the appropriate skills, knowledge, experience, and roles to perform the review effectively1. There should also be an emphasis on learning and process improvement, as reviews can provide feedback and suggestions to improve the software artifacts, processes, and skills of the participants1. Therefore, these characteristics are typically found to enable the review process to be successful.

 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 test execution schedule should take into account the prioritization and other constraints given in the question. The first activity is to run any re-tests, followed by the regression test script. Users have supplied their priority order to tests. Therefore, the test execution schedule should start with the re-test defect no 52, which is shown in the image as a table with 9 rows and 4 columns. The table is titled “Re-test defect no 52”. The columns are labeled: “#”, “Description”, “Priority”, “Note”, “Re-test”. The table is populated with data about different tasks and their priority and notes. The tasks are related to sales figures and account administration. The table is in black and white. The re-test defect no 52 has three tasks: c, a, and d, which have priority 1, 2, and 3 respectively. Therefore, the test execution schedule should start with c, followed by a, and then d. After that, the regression test script should be run, which is task e. Then, the remaining tasks should be run according to the user priority order: b, g, i, h, and f. Therefore, the test execution schedule is c, a, d, e, b, g, i, h, and f.

 A role of a formal review is B. Moderator. A formal review is a type of static technique that involves a structured process of examining code or other software artifacts by a team of reviewers who follow predefined roles and rules. A formal review has four main phases: planning, preparation, meeting, and follow-up. A formal review has five main roles: author (the person who created the code or other software artifact under review), moderator (the person who leads and facilitates the review process), reviewer (the person who examines the code or other software artifact under review and provides feedback), scribe (the person who records the issues and outcomes of the review meeting), and manager (the person who monitors and controls the review process). A moderator is a key role in a formal review because he or she is responsible for planning, organizing, conducting, and reporting the review activities and ensuring that the review objectives are met. A detailed explanation of formal reviews can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 35-37.

 Functional testing to test security at the system level, load testing at the system level to ensure the system availability is acceptable, regression testing at all levels, structure based testing at the component level only are the test types that will be required during the development1. A bank is developing a new service that will be delivered via the web. The user interactions are defined as a set of use cases and the service is designed to be available continuously 24/7. In view of the challenging characteristics of the service, the test manager has decided that the code should be thoroughly tested at component level. Therefore, the following test types will be required during the development:

• Functional testing to test security at the system level: This type of testing verifies that the software product performs its intended functions according to the user requirements and expectations1. Security is one of the functional aspects that needs to be tested at the system level, as it ensures that the software product protects itself from unauthorized access or harm1.
• Load testing at the system level to ensure the system availability is acceptable: This type of testing verifies that the software product can handle the expected or peak load of users or transactions without degrading its performance or functionality1. Availability is one of the quality attributes that needs to be tested at the system level, as it measures how well the software product performs its intended functions under specified conditions without interruption or failure1.
• Regression testing at all levels: This type of testing verifies that previously tested software still performs correctly after changes or defect corrections1. Regression testing is required at all levels of testing, as changes or defect corrections can introduce new defects or affect existing functionality1.
• Structure based testing at the component level only: This type of testing uses the structure or logic of the source code as a test basis to derive test cases and measure test coverage1. Structure based testing is required at the component level only, as the test manager has decided that the code should be thoroughly tested at component level to ensure its quality and reliability1.

 Testers identify defects, developers locate and correct defects, testers confirm the correction has cleared the original defect. Debugging is the process of finding and fixing defects in a software product by analyzing its code or behavior. Debugging is usually performed by developers who have access to and knowledge of the code or structure of the software product. Debugging involves locating and correcting defects identified by testers during testing activities, and verifying that the correction has cleared the original defect without introducing new defects. Testers can also participate in debugging by providing information about how to reproduce defects, what are the expected results, what are the actual results, etc., and by confirming that defects have been fixed after debugging. A detailed explanation of debugging can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], page 6.

The question asks which of the test cases will ensure that the statement ‘Print ‘Hold’’ is exercised. The statement ‘Print ‘Hold’’ is executed when X > Y and Z < Y. Therefore, to exercise this statement, we need to choose a test case that satisfies these conditions. Among the options given in this question, only C satisfies these conditions. X = 42 > Y =43 and Z =42 < Y =43. Therefore, C is the correct answer.

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.

Experience-based test design techniques are techniques that use the skill, intuition, and experience of testers to derive test cases, using error guessing and exploratory testing1. Error guessing is a technique that uses common sense and previous experience to guess where defects might occur in a system1. Exploratory testing is an approach that involves simultaneous learning, test design, and test execution1. Experience-based test design techniques are typically used when there is insufficient information or time to apply other more formal techniques1. They do not use decision tables, identify the structure of the system or software, or establish traceability from test conditions back to the specifications and requirements.

 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)

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.