CTFL_Syll2018 Exam Dumps - ISTQB Certified Tester Foundation Level (Syllabus 2018)

A circumstance where maintenance testing is required is A. Migration of software onto a new platform. Migration of software onto a new platform is a type of change that affects the delivered software product and requires maintenance testing to ensure that the software product still works correctly and consistently on the new platform. A new platform can be a different hardware, operating system, network, database, browser, etc., that supports or interacts with the software product. Migration of software onto a new platform can introduce compatibility issues, performance issues, security issues, etc., that need to be detected and resolved by maintenance testing. A detailed explanation of migration testing can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], page 82.

Independence from the production process is a characteristic that is most likely to promote effective software testing1. Independence from the production process means that the testers are not involved in the development or maintenance of the software product under test, and thus can provide an unbiased and objective view of its quality1. Independence from the production process can also help to avoid conflicts of interest, reduce confirmation bias, increase defect detection, and improve test coverage1. Therefore, independence from the production process is a characteristic that is most likely to promote effective software testing.

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

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

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 effective ways to improve the communication and relationship between testers and others are A. a and b. Communicating factual information in a constructive way and trying to understand how the other person feels and why they react the way they do are both important skills for testers to have. Testers often have to report defects and problems that may not be well received by developers or users. Therefore, testers should communicate in a clear, objective, and respectful manner, avoiding personal attacks or blame. Testers should also empathize with the other person’s perspective and emotions, and try to resolve any conflicts or misunderstandings in a positive way. A detailed explanation of communication skills for testers can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 107-108.

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

 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.

The fundamental test process is a generic model that describes the main activities and tasks involved in testing. The fundamental test process consists of five phases: planning and control, analysis and design, implementation and execution, evaluation of exit criteria and reporting, and test closure activities. Implementation and execution is the phase where test cases and test procedures are implemented according to test specifications and executed on the system or component under test using test tools or manual methods. Implementation and execution also involves verifying that the test environment set up is correct, which means ensuring that the test environment (such as hardware, software, network, data, etc.) is ready and suitable for testing the system or component under test. A detailed explanation of implementation and execution can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 19-21.

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.

Equivalence partitioning is best defined as an analysis technique that divides inputs into groups that are expected to exhibit similar behaviors. The idea is to reduce the number of test cases by selecting one representative value from each group or partition. Equivalence partitioning does not apply to time-related data classes only, but to any type of input data that can be divided into partitions. Equivalence partitioning is not a form of white-box testing, but a black-box testing technique. Equivalence partitioning is not a method to reduce test coverage, but a method to achieve test coverage more efficiently.

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

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

Planning and control, analysis, design, implementation, execution, evaluation of exit criteria and reporting, test closure. The fundamental test process is a generic model that describes the main activities and tasks involved in testing. The fundamental test process consists of five phases: planning and control, analysis and design, implementation and execution, evaluation of exit criteria and reporting, and test closure activities. Each phase has specific objectives, inputs, outputs, and deliverables. A detailed explanation of the fundamental test process can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 13-241.

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

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

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

 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)

 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.

Software testing contributes to the quality of delivered software by identifying root causes of defects from past projects and using the lessons learned to improve processes and thus help to reduce the defect count. Software testing is a process of verifying and validating that a software product meets the specified requirements and expectations of the stakeholders1. Software testing can detect defects in the software product and provide information about its quality1. Software testing can also identify root causes of defects from past projects and use the lessons learned to improve processes and thus help to reduce the defect count1. This can be done by using techniques such as root cause analysis, defect prevention, causal analysis, process improvement, etc1. These techniques can help to identify and eliminate the sources of defects in the software development lifecycle and prevent them from recurring in future projects1. Therefore, software testing contributes to the quality of delivered software by identifying root causes of defects from past projects and using the lessons learned to improve processes and thus help to reduce the defect count.

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

Test cases derived from the knowledge of the testers and the knowledge of testers, developers and users are used to drive testing apply to experience-based techniques1. Experience-based techniques are techniques that use the skill, intuition, and experience of testers, developers, and users 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 techniques are typically used when there is insufficient information or time to apply other more formal techniques1. Therefore, test cases derived from the knowledge of the testers and the knowledge of testers, developers and users are used to drive testing apply to experience-based techniques.

• 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

Statement coverage is not a black box technique, because it requires knowledge of the internal structure of the code. Black box techniques are based on the external behavior and specification of the software, without looking at the code. Equivalence partitioning, state transition testing, and boundary value analysis are all examples of black box techniques12

 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.

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.

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.

Screen-dialog flows are sequences of screens and dialogs that represent the user interface and interaction of a system. Use case testing is a technique that uses use cases as a test basis to derive test cases1. A use case is a description of interactions between actors and a system to achieve a goal1. Use case testing is the most effective technique in testing screen-dialog flows, as it can capture the user requirements, scenarios, and expected outcomes of the system. Boundary value testing is a technique that uses boundary values as a test basis to derive test cases1. A boundary value is an input value or output value on the edge of an equivalence partition or at the smallest or largest value of a range1. Boundary value testing is not the most effective technique in testing screen-dialog flows, as it is more suitable for testing numerical inputs and outputs. Statement testing and coverage is a technique that uses statements in the source code as a test basis to measure the coverage achieved by a test suite1. A statement is a minimal executable unit of source code1. Statement testing and coverage is not the most effective technique in testing screen-dialog flows, as it is more suitable for testing the internal logic and structure of the code. State transition testing is a technique that uses state transition diagrams as a test basis to derive test cases1. A state transition diagram shows the states of a system and the transitions between them triggered by events or conditions1. State transition testing is not the most effective technique in testing screen-dialog flows, as it is more suitable for testing systems that have complex or dynamic behavior based on different states.

 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.

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.

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.

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.

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.

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.

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

To achieve 100% statement coverage, we need to execute every statement in the code at least once. To achieve 100% decision coverage, we need to execute every possible outcome of every decision in the code at least once. In this case, we can use the following test cases to cover both statement and decision coverage:

• A = 5, B = 4, C = 3, D = 2, E = 1
• A = 1, B = 2, C = 3, D = 4, E = 5
• A = 3, B = 4, C = 5, D = 2, E = 1
• A = 3, B = 2, C = 1, D = 4, E = 5

These four test cases will cover all the statements and all the possible outcomes of the decisions in the code. Therefore, the minimum number of test cases required to achieve both statement and decision coverage is four.

References: Certified Tester Foundation Level Syllabus, Section 4.3.1

According to the user story checklist, the user story must contain the reason for the need, which is usually expressed by using the word “so that” or “because”. For example, the user story could be rewritten as:

User Story US2018 As a bank account customer, I would like to transfer money from one account to another using the mobile banking application by using the drag and drop feature, so that I can easily manage my finances.

This way, the user story provides a clear value proposition and a justification for the need. The reason also helps to define the scope and priority of the user story, as well as to verify the acceptance criteria.

References: ISTQB Certified Tester Foundation Level (CTFL) v4.0 Syllabus, Chapter 5.2.1 User Stories, p. 62-631; ISTQB Certified Tester Foundation Level (CTFL) v4.0 Sample Exam Questions and Answers, Question 83, p. 232

Load testing tool checks for time response and resource utilization of a system under a specific load condition or scenario. Load testing tool can simulate multiple users accessing or performing operations on a system concurrently and measure how long it takes for the system to respond and how much CPU, memory, disk or network resources are consumed by the system.

In a Scrum development life cycle model, regression testing is an increasingly important activity as the project progresses. Scrum is an agile framework that follows an iterative and incremental approach to software development, where the software is delivered in small units called sprints. Regression testing is a type of testing that verifies that previously tested software still performs as expected after changes or modifications. Regression testing is essential in Scrum, as new features or functionalities are added or modified in each sprint, which can introduce new defects or affect existing ones. Therefore, regression testing should be performed at the end of each sprint, as well as before releasing the software, to ensure that the software meets the quality standards and user expectations.

References: Certified Tester Foundation Level Syllabus, Section 5.3.2

The test execution schedule that meets the test plan requirements and logical dependencies is e, a, d, c, b. This schedule follows the order of re-tests first (e), followed by the highest priority tests (a and d), and then creates test data for subsequent tests (c and b). This schedule also respects the logical dependencies, as test case a creates an admin user, which is necessary for test case d to create a standard user, which is necessary for test cases c and b to perform other actions1 .

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

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, non-functional testing is a type of software testing that verifies non-functional aspects or attributes of a software product or system, such as performance, usability, reliability, security, etc. Non-functional testing evaluates how well a system operates or behaves under certain conditions or scenarios, rather than what functions or features it provides. The answer D is correct because it best exemplifies non-functional testing. Tests which capture the time it takes to save a file are examples of performance testing, which is a type of non-functional testing that measures how fast or responsive a system is under various workloads or situations. The other answers are incorrect because they exemplify functional testing or structural testing, which are not types of non-functional testing. Tests based on the internal structure of a component or system (A) are examples of structural testing, which is a type of software testing that verifies the implementation or code of a software product or system. Tests related to ‘what’ the system should do (B) are examples of functional testing, which is a type of software testing that verifies the functionality or behavior of a software product or system. Tests which calculate overtime pay for those employees entitled to such © are also examples of functional testing, as they verify a specific function or feature of a software product or system.

References: Certified Tester Foundation Level Syllabus, Section 1.2.1, page 10-11.

A walkthrough is lead by a moderator and requires pre-meeting preparation and post meeting follow up is the statement that is not true about walkthroughs, because it describes a different type of review called inspection . A walkthrough is a type of informal review that involves the author of a document presenting it to a group of peers or stakeholders to establish a common understanding and to find possible defects . A walkthrough does not have a moderator, but rather an author who leads the review. A walkthrough does not require pre-meeting preparation or post meeting follow up, but rather relies on the author’s knowledge and skills . The other options are true statements about walkthroughs. Option B is true, because a walkthrough may take the form of scenarios, dry runs and peer group review, depending on the type and purpose of the document being reviewed . Option C is true, because the purpose of a walkthrough is to establish common understanding of a document and to find possible defects in it . Option D is true, because pre-meeting preparation, documentation and distribution of results are optional for a walkthrough, as they depend on the author’s discretion and preference .

Code coverage can be used to ensure that all code is exercised by tests, because it measures how much of the code or functionality of the software under test has been exercised by the test cases . Code coverage can help to identify untested or dead code, improve test design, and assess test quality . The other options are not true statements about code coverage. Option A is false, because 100% code coverage does not imply 100% coverage of requirements, as there may be defects or gaps in the requirements or in the mapping between requirements and code . Option B is false, because 100% code coverage does not guarantee that there are no coding errors, as there may be logical or functional errors that are not detected by code coverage . Option D is false, because code coverage does not ensure that all decisions are correctly implemented in the code, as it only measures whether the decisions are executed or not, but not whether they produce the correct results .

Use case testing does not find defects caused by interaction of different components is the statement that is false about use case testing. Use case testing is a technique to create test cases based on use cases, which are descriptions of how a system interacts with one or more actors (users or other systems) to achieve a specific goal or function. Use case testing can find defects caused by interaction of different components, as use cases often involve multiple components working together to provide a service or functionality to an actor2 explains use case testing as follows:

Use case testing is a technique that helps us identify test cases that exercise the whole system on a transaction by transaction basis from start to finish. It is a functional black box testing technique.

Use cases are prepared by analysts and domain experts who document the functional requirements of a system from an end-user perspective. Each use case typically has a mainstream scenario and may have alternate or exceptional scenarios that describe different paths or outcomes.

Use case testing can help to verify that all the interactions between actors and the system under test work as expected and meet the user requirements. It can also help to detect integration defects between different components or subsystems.

A, B, and D are correct statements about use case testing. Use case generally has a mainstream scenario and may have many alternate or exceptional scenarios (A), as use cases describe different paths or outcomes depending on various conditions or events. A use case can be defined at different levels of abstraction, such as user goal level, summary level, subfunction level, etc., but not at the abstract level detached from the implementation or at the system level describing a set of executed functions (B), as use cases always describe interactions between actors and systems rather than abstract concepts or functions. Each use case has preconditions which need to be met for the use case to work successfully (D), as preconditions specify what must be true before a use case can begin.

Agile development can be classified as an iterative incremental life cycle model, where each iteration delivers a working product increment that can be evaluated by stakeholders and users. describes this as follows:

Iterative Incremental Development Model is a process where creating requirements, designing, building and testing a system in small parts. This model divided into small parts which will help to make modules very easily.In this model, module passes through some phases like requirements, coding, designing, testing.

Agile Model mostly recommended to use for current software development industries because it is very realistic approach to develop any kind of software.It follows iterative approach which means whole project divided into small iterations or modules.

Agile development is not related to any life cycle model (A), RAD (B), or V model ©.

Test design is the process of transforming general testing objectives into tangible test conditions and test cases that can be executed and verified against expected results. Test design involves identifying test techniques, coverage criteria, input data, expected outcomes and other test parameters.

Configuration management is related to ensuring the integrity of the testware, as it is a process that controls and documents changes to test items, test cases, test data, test scripts, test results, and test documentation throughout the testing lifecycle. The other options are not related to ensuring the integrity of the testware, but to other aspects of testing such as test execution, test environment setup, and test planning.

References: Section 4.1, Section 4.2

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

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

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

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

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

References:

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

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, configuration management is a process that establishes and maintains the consistency of a product’s attributes throughout its life cycle. It involves identifying, controlling, tracking, and auditing changes to the product’s components and documentation. Configuration management supports the test process by enabling the tester to reproduce the tested item through unique identification and version control. This ensures that the tester knows exactly what has been tested and can trace any defects or incidents to the correct version of the software under test. The answer A is correct because it best describes how configuration management supports the test process. The other answers are incorrect because they describe other aspects of testing that are not directly related to configuration management.

References: Certified Tester Foundation Level Syllabus, Section 2.2.1, page 22-23.

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.

 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

In the context of software testing, the correct sequence of events typically starts with a mistake, which is a human error made during the software development process. This mistake can lead to a fault in the code, which is a defect or bug that exists in the software. If this fault is executed, it may cause a failure, which is an instance where the software does not perform its intended function.

References: The ISTQB Certified Tester Foundation Level (CTFL) v4.0 documents provide detailed explanations of these terms and their sequence. Specifically, the syllabus outlines the fundamental concepts of software testing, including the definitions and differences between errors, faults, and failures.

The best way to take advantage of the different mindsets of testers and developers is to bring the two mindsets together. Testers and developers have different perspectives and skills that can complement each other and improve the quality of the software. Testers tend to focus on finding defects and verifying the software against the requirements and specifications, while developers tend to focus on creating and implementing the software according to the design and architecture. By collaborating and communicating with each other, testers and developers can share their knowledge, feedback, and ideas, and resolve issues more efficiently and effectively.

References: Certified Tester Foundation Level Syllabus, Section 2.2

Checklist-based testing is an experience-based test technique whereby the experienced tester uses a high-level list of items to be noted, checked or remembered, or a set of rules or criteria against which a product has to be verified. Checklist-based testing can help the tester to focus on important aspects of the test object and to ensure that nothing is overlooked or forgotten. Checklist-based testing can also help the tester to communicate and report the test results and coverage more effectively.

References: Certified Tester Foundation Level Syllabus, Section 4.6.1

Testing and debugging are two different activities that are related to finding and removing defects and failures in software. Testing is the process of evaluating software by applying test cases to find failures and provide information on its quality. Debugging is the process of finding, analyzing, and removing the causes of failures in software. Designing tests to find failures and executing tests to show failures are testing activities. Locating the cause of failures and analyzing and fixing the defects are debugging activities.

References: Certified Tester Foundation Level Syllabus, Section 1.2.1

Black-box testing is a test technique that investigates the input vs. output behavior of a software system, without considering its internal structure or implementation. Therefore, option B is correct. Option A is incorrect, as it describes white-box testing, which focuses on the internal structure or implementation of a software system. Option C is incorrect, as it describes exploratory testing, which relies on the testers’ intuition and experience. Option D is incorrect, as it describes integration testing, which tests the interfaces and interactions between components or systems.

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

 Having the company’s independent test team design and execute the tests would achieve the highest level of testing independence for a project’s test level, because it would reduce the bias and influence of the developers or other stakeholders who are involved in the software development1 . An independent test team can provide a different perspective and focus on testing activities without being affected by development pressures or deadlines1 . The other options would not achieve the highest level of testing independence for a project’s test level. Option A is not a good option, because training developers to design good tests for the test team to execute would still introduce some bias and influence from the developers’ point of view1 . Option C is not a good option, because minimizing contact between testers and developers during test design to avoid bias would reduce the communication and collaboration that are essential for effective testing and defect resolution1 . Option D is not a good option, because outsourcing test design and execution to a different company would introduce some risks and challenges such as contractual issues, cultural differences, or loss of control over quality

Both functional and structural approaches are used in integration tests. Functional testing verifies that the integrated components work together as expected, while structural testing checks the internal structure and logic of the integrated components1 explains this in more detail:

Integration testing is a level of software testing where individual units are combined and tested as a group. The purpose of this level of testing is to expose faults in the interaction between integrated units. Test drivers and test stubs are used to assist in Integration Testing.

Integration testing can be done in two ways:

• Bottom-up Integration Testing: Bottom up integration testing begins with unit testing, followed by tests of progressively higher-level combinations of units called modules or builds.
• Top-down Integration Testing: In top down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that.

Statement testing is a white box test technique2. A white box technique is a technique that uses the internal structure or logic of a system as a test basis to derive test cases and measure test coverage2. Statement testing is a technique that uses executable statements in the source code as a test basis to measure the coverage achieved by a test suite2. A statement is an instruction or command that performs an action or calculation in the source code2. Statement testing requires every statement in the source code to be executed at least once by a test suite2. Therefore, statement testing is a white box test technique.

TC1 - £23 total charges including buggy hire; TC2 - £16 total charge but no buggy allowed. This answer can be derived from the decision table by matching the conditions of each test case with the corresponding rules and actions. For TC1, the conditions are: Loyalty Card holder = Y, 18 Holes = Y, Buggy/Cart Request = Y. These conditions match Rule 1, which has the actions: Green Fee = £18, Buggy Hire = £5, Total Charge = £23. For TC2, the conditions are: Loyalty Card holder = N, 18 Holes = N, Buggy/Cart Request = Y. These conditions match Rule 3, which has the actions: Green Fee = £16, Buggy Hire = Not Allowed, Total Charge = £16

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

Priority is an important item of information that is missing from the incident report. Priority indicates the importance or urgency of resolving the incident, based on the business needs and the impact on the stakeholders. Priority is usually assigned by the project manager or the customer, and it helps to determine the order in which incidents should be addressed. Priority may differ from severity, which indicates the degree of impact of the incident on the system or the component under test. Severity is usually assigned by the tester or the developer, and it helps to assess the risk of the incident. For example, an incident may have a high severity but a low priority, if it affects a critical function but only occurs in a rare situation. Conversely, an incident may have a low severity but a high priority, if it affects a minor function but occurs frequently or affects many users. Therefore, both priority and severity are useful information for incident management and resolution.

The other options are not essential information for the incident report, although they may be helpful or desirable in some cases. Recommendations are suggestions or proposals for resolving the incident, which may be provided by the tester, the developer, or other stakeholders. However, recommendations are not mandatory, and they may not be feasible or acceptable in some situations. Name of tester is the identifier of the person who reported the incident, which may be useful for communication or accountability purposes. However, name of tester is not critical, and it may be replaced by other identifiers, such as email address, employee number, or role. Change history is the record of the changes made to the incident report, such as status, resolution, or comments. Change history is valuable for tracking and auditing purposes, but it is not part of the initial incident report, rather it is updated as the incident progresses.

References: ISTQB Certified Tester Foundation Level Syllabus v4.0, Chapter 5.3.2, p. 49-50 1; ISTQB Glossary v4.0, p. 38-39 2

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

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

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

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

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

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

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

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 correct answer is D, as it describes exploratory testing. Exploratory testing is an experience-based test technique that involves simultaneous learning, test design, and test execution1. Exploratory testing may be used within defined time periods, during which the tester may follow a test charter as a guide. A test charter is a document that specifies the scope, objective, and approach of an exploratory testing session1. Option A is incorrect, as exploratory testing is not a suitable test technique that may replace both black-box and white-box test techniques, but a complementary technique that can be used along with other techniques1. Option B is incorrect, as exploratory testing does not require both solid specifications and much project time available for test execution, but can be used in situations where specifications are incomplete or changing and where time is limited1. Option C is incorrect, as exploratory testing is not a valid and useful black-box test technique since it focuses on test cases related to the architecture and design of a system, but an experience-based test technique that focuses on learning about the system and its behavior1. References: 1, Section 4.2.6

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

 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.

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.

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

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

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

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

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.

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

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.

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.

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.

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.

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.

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.

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

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

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

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

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.

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.

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.

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.

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.

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.

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

The requirement given in the image specifies 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.

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.

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

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.

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.

Test techniques are methods or procedures that can be used to design, execute, or evaluate test cases. Test techniques can be classified into two categories: specification-based and structure-based. Specification-based test techniques, also known as black-box test techniques, are based on the requirements, specifications, or expectations of the system under test. They do not require any knowledge of the internal structure or implementation of the system. Some examples of specification-based test techniques are use case testing, state transition testing, decision table testing, etc. Structure-based test techniques, also known as white-box test techniques, are based on the code, architecture, or design of the system under test. They require some knowledge of the internal structure or implementation of the system. Some examples of structure-based test techniques are control flow testing, data flow testing, branch testing, statement testing, etc. You can find more information about test techniques in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, Chapter 41.

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.

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

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.