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

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

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

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.

 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)

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.

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.

The statement that BEST describes the relationship between test planning and test execution is A. Test planning ensures the level of detail in test procedures is appropriate for test execution. Test planning is the process of defining the objectives, scope, approach, resources, schedule, risks, and deliverables for testing activities. Test planning also involves designing and creating test cases and test procedures for test execution. Test procedures are detailed instructions on how to execute each test case and record the results. Test planning ensures that the level of detail in test procedures is appropriate for test execution, by considering factors such as complexity of the system under test, skills and experience of testers, availability of tools and environments, etc. Test planning also ensures that test procedures are consistent with the test objectives and cover all relevant aspects of testing (such as functional testing, non-functional testing, regression testing etc.). A detailed explanation of test planning can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 13-151.

Use-case testing is a technique that uses use-cases as a test basis to derive test cases2. A use-case is a description of interactions between actors and a system to achieve a goal2. An actor represents a type of user or anything that interacts with the system2. Use-cases are not the most common test basis for unit testing, as they are more suitable for higher levels of testing such as system or acceptance testing3. An actor is not always a human user, as it can also be another system or device2. Test cases can be based on use-case scenarios, which are sequences of actions and events that occur during a use-case execution2. Use-case testing will often identify gaps not found by testing individual components, as it can reveal missing or incorrect requirements, integration issues, and usability problems.

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 application failed because of a defect in the purchase identification module caused by a programmer mistake or an error in the specification. A defect is a flaw or imperfection in a software product that causes it to fail to meet its requirements or expectations. A failure is an event or behavior of a software product that deviates from its requirements or expectations. An error is a human action or decision that produces a defect. A mistake is an incorrect action or decision that leads to an error. In this case, the application failed because it incorrectly counted purchase attempts, which was a defect in the purchase identification module. The defect was caused by either a programmer mistake (such as writing wrong code) or an error in the specification (such as defining wrong requirements). A detailed explanation of defects, failures, errors, and mistakes can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 5-6.

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

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.

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

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

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

!flow graph

The following test cases have been run:

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

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

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

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

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

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

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

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

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.

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.

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

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

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

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.

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

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

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

The choice of software development model depends on product and project characteristics1. A software development model is a framework that defines the activities, tasks, roles, and deliverables of a software project1. There are various software development models, such as waterfall, V-model, iterative, incremental, agile, etc1. The choice of software development model depends on product and project characteristics, such as size, complexity, scope, requirements, quality attributes, risks, resources, schedule, budget, etc1. Different software development models have different advantages and disadvantages for different types of products and projects1. Therefore, the choice of software development model depends on product and project characteristics.

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

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

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 statement that best characterizes maintenance testing is A. Maintenance testing is triggered by changes to delivered software and uses impact analysis to minimize the amount of regression testing needed. Maintenance testing is a type of testing that is performed on a software product after it has been delivered to the customer or user, and aims to ensure that the software product still meets its requirements and expectations after any changes or modifications. Maintenance testing is triggered by changes to delivered software, such as bug fixes, enhancements, patches, updates, etc., and uses impact analysis to determine the scope and extent of regression testing needed. Impact analysis is a technique that analyzes the potential effects of changes on the existing software product and its components, dependencies, interfaces, etc., and identifies which parts of the software product need to be retested or modified. Impact analysis helps to minimize the amount of regression testing needed by focusing on the most affected or critical parts of the software product. A detailed explanation of maintenance testing can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 81-82.

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.

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

 S2 and O2 are the finishing state and the output(s) from the test case1. The question asks about a test case that starts at S1 and triggers 4 events in sequence: E1, E4, E5, E7. The question refers to a state diagram that shows the logic of a system with six states (S1, S2, S3, S4, S5, S6) and seven events (E1, E2, E3, E4, E5, E6, E7). The state diagram also shows four outputs (O1, O2, O3, O4) that are produced by some events. The state diagram is shown below:

!state diagram

To answer this question, we need to follow the path of the test case on the state diagram and observe the state transitions and outputs that occur. The path of the test case is:

• Start at S1
• Trigger E1
• Transition to S2
• Trigger E4
• Transition to S3
• Trigger E5
• Transition to S2
• Output O2
• Trigger E7
• Transition to S6

Therefore, the finishing state of the test case is S2 and the output(s) from the test case is O2. Hence, D is the correct answer.

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

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

The correct answer is D, as DT1 and DT4 would achieve full coverage of the full decision table when combined with the test cases that have already been generated for rules 1 and 4. Decision table testing is a black-box test technique that uses a table to show combinations of inputs and their associated outputs1. In this case, the inputs are the account type, the amount entered, and the expected result. The outputs are the actions taken by the ATM system. The decision table has eight rules, each corresponding to a possible combination of inputs and outputs. The test cases that have already been generated for rules 1 and 4 are:

• TC1: Account = Checking, Amount = $600, Expected Result = Process the transaction
• TC4: Account = Savings, Amount = Not entered, Expected Result = Generate an error message

The additional test cases are:

• DT1: Account = Checking, Amount = Not entered, Expected Result = Generate an error message
• DT2: Account = Savings, Amount = $100, Expected Result = Process the transaction
• DT3: Account = Checking, Amount = $100, Expected Result = Process the transaction
• DT4: Account = Savings, Amount = $600, Expected Result = Generate an error message

To achieve full coverage of the full decision table, two more test cases are needed that cover the remaining six rules. DT1 and DT4 cover these rules, as shown in the table below:

Therefore, option D is the correct answer. Options A, B, and C are incorrect, as they do not cover all the rules in the decision table. References: 1, Section 4.2.5

According to the syllabus, decision tables are a technique that shows combinations of inputs and/or stimuli (causes) with their associated outputs and/or actions (effects). The answer B is correct because it matches the rules in the decision table for the given test case. The other answers are incorrect because they do not match the rules in the decision table for the given test case.

References: Certified Tester Foundation Level Syllabus, Section 4.3.1, page 44-45.

Gaining confidence about the level of the system’s quality can be a common objective of testing, because testing can provide information about how well the system meets its specified requirements and user expectations, and how many defects have been found and fixed in the system.

 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

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.

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

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

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

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

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

The version of the application is missing from the defect report. This is a valid criticism because it is important to specify which version of the software was tested when the defect was found, as this can help to identify and reproduce the defect, and to verify if it has been fixed in a later version.

The correct answer is A, as it provides the best test execution schedule that takes into account the priorities and technical and logical dependencies. A test execution schedule is a plan that defines the order and timing of test cases to be executed based on various factors such as dependencies, risks, priorities, and resources1. In this case, the factors are the priorities and technical and logical dependencies of the test cases. The priorities are the levels of importance or urgency assigned to the test cases, such as low, medium, or high1. The technical dependencies are the relationships between the test cases that require one test case to be executed before another test case can be executed1. The logical dependencies are the relationships between the test cases that make sense to execute one test case after another test case for better understanding or efficiency1. Option A provides the best test execution schedule that takes into account these factors, as it follows these rules:

• Execute high priority test cases before medium or low priority test cases
• Execute test cases that have technical dependencies in the correct order
• Execute test cases that have logical dependencies in a sensible order

The following table shows how option A follows these rules:

Option B does not follow these rules, as it executes TC1 before TC2, which violates the technical dependency. Option C does not follow these rules, as it executes TC5 before TC6, which violates the logical dependency. Option D does not follow these rules, as it executes TC2 before TC3, which violates the technical dependency. References: 1, Section 2.5

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

 The correct roles and responsibilities in a formal review are as follows1:

• Review Leader - Plans and leads the review process
• Scribe - Documents all issues raised during the review meeting
• Author - Creates the work product under review
• Facilitator - Supports the review leader in conducting the review process
• Reviewers - Identify potential defects in the work product under review

Therefore, option B is the correct answer, as it correctly matches the role of scribe with the responsibility of collating potential defects found during the individual review activity. Options A, C, and D are incorrect, as they do not match the roles and responsibilities correctly. References: 1, Section 3.2.3

  A bug report is a document that records the details of a defect or failure found during testing, such as the steps to reproduce, the expected and actual results, the severity and priority, etc. A bug report should also include any observations or suggestions that may help correct the bug, such as the possible cause, the affected components, the related requirements, etc. This information can help the developers to locate and fix the bug more efficiently and effectively. Therefore, if a tester thinks of a likely cause for a specific bug, they should make a comment about it in the bug report.

References: Certified Tester Foundation Level Syllabus, Section 6.

Any software development product can undergo static testing, including requirements specifications, design specifications, code, test cases, test plans, user manuals, etc. Static testing is a type of testing that does not involve executing the software or system under test, but rather analyzing it using various techniques, such as reviews, inspections, walkthroughs, checklists, static analysis tools, etc. Static testing can help find defects and improve the quality of any software development product at any stage of the software development lifecycle.

References: Certified Tester Foundation Level Syllabus, Section 3.1 and 3.2

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. Testing reveals failures, which are deviations of the actual behavior of the software from its expected behavior. Debugging removes defects, which are flaws in the software that cause failures.

References: Certified Tester Foundation Level Syllabus, Section 1.2.1

The pesticide paradox principle of testing states that if we do not regularly review and revise our tests, we’ll stop finding defects, because the same tests will no longer be effective at detecting new or different defects in the software12. The other options do not explain the pesticide paradox principle of testing. Option B is false, because repeatedly running a set of tests will not ensure that a system is defect free, but rather that it meets the same quality criteria as before12. Option C is related to the defect clustering principle of testing, which states that defects are often contained in a small number of modules12. Option D is a metaphor that compares testing to spraying pesticide, but it does not explain the paradoxical effect of using the same tests over and over again

 The level of risk is determined by multiplying the impact of an adverse event by the likelihood of that event occurring1 . The impact of an adverse event is the degree of harm or loss that would result from the event, such as financial loss, reputation damage, legal consequences, or safety hazards1 . The likelihood of an adverse event is the probability or frequency of the event happening, based on historical data, expert judgement, or statistical analysis1 . The other options are not correct formulas for calculating risk. Option A confuses the cost of preventing an adverse event with its impact. Option B confuses the cost of possible legal action with its likelihood. Option D uses two synonyms for likelihood (probability and frequency) instead of combining it with impact.

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

According to the syllabus, regression testing is a type of software testing that verifies that previously developed and tested software still performs as expected after a change. A change can be any modification in the software product or system, such as bug fixes, enhancements, configuration changes, etc. Regression testing helps to ensure that the change does not introduce new defects or affect existing functionality. Confirmation testing is a type of software testing that verifies that a specific defect has been fixed after a change. Confirmation testing is also known as re-testing. Confirmation testing helps to ensure that the change has resolved the defect and does not introduce new defects. The answer C is correct because it best matches the type of testing with the testing scenario. Testing to ensure the application of a new version of the operating system does not have any unintended side-effects on the system (1) is an example of regression testing, as it verifies that the change in the operating system does not affect the functionality of the system. Testing due to the application of a security patch (2) is also an example of regression testing, as it verifies that the change in the security patch does not affect the functionality of the system. Testing due to the application of a new version of the database management system (3) is another example of regression testing, as it verifies that the change in the database management system does not affect the functionality of the system. Testing to ensure the fix to the payroll system truly works (4) is an example of confirmation testing, as it verifies that the change in the payroll system has fixed a specific defect. The other answers are incorrect because they do not match the type of testing with the testing scenario correctly.

References: Certified Tester Foundation Level Syllabus, Section 5.1.1, page 56-57.

The correct answer is D, as it describes a test summary report for executive-level employees. A test summary report is a document that summarizes the results and evaluation of testing activities for a specific activity or phase3. It may have different levels of detail and content depending on the intended audience and purpose3. A test summary report for executive-level employees is typically high-level and includes a status summary of defects by priority or budget3. This type of report provides a concise overview of the quality and progress of testing without going into too much detail or technical information3. Option A is incorrect, as it describes a test summary report for technical-level employees. A test summary report for technical-level employees is typically detailed and includes specific information on defects and trends3. This type of report provides a comprehensive analysis of the quality and progress of testing with relevant data and metrics3. Option B is incorrect, as it describes a test summary report that is neither suitable for executive-level nor technical-level employees. A test summary report that is detailed and includes a status summary of defects by priority or budget is too detailed for executive-level employees and too vague for technical-level employees3. Option C is incorrect, as it describes a test summary report that is neither suitable for executive-level nor technical-level employees. A test summary report that is high-level and includes specific information on defects and trends is too high-level for technical-level employees and too specific for executive-level employees3. References: 3, Section 2.7

The test execution schedule should follow the priority order of the tests, as well as the dependency constraints. The priority order is given by the user value column, where higher values indicate higher priority. The dependency constraints are given by the dependency column, where a test ID indicates that the test cannot be run until the test with that ID has been successfully completed. Therefore, the test execution schedule should start with the highest priority test that has no dependency, which is test 5. Then, it should continue with the next highest priority test that has no dependency or has a satisfied dependency, which is test 1. Then, it should proceed with test 2, which depends on test 1, and then test 3, which depends on test 2. Finally, it should end with test 4, which depends on test 3. Thus, the test execution schedule that best meets the prioritisation and dependency conditions is 5,1,2,3,4.

References: ISTQB Certified Tester Foundation Level (CTFL) v4.0 Syllabus, Chapter 6.1.2 Test Execution, p. 781; ISTQB Certified Tester Foundation Level (CTFL) v4.0 Sample Exam Questions and Answers, Question 87, p. 242

Regression testing is intended to find side-effects after changes have been applied to the system under test. Side-effects are unintended consequences of changes that may cause new defects or re-introduce previously fixed defects in parts of the system that were not directly modified. Regression testing can be done at any level of testing and can use any type of testing technique.

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

References: Certified Tester Foundation Level Syllabus, Section 4.2.2

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

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

A functional test is a dynamic test for which the tests are based on the specification of the test object. This means that the test cases and test data are derived from the functional requirements, use cases, user stories, or other sources that describe the expected behavior and functionality of the system under test. A functional test is not focused on the efficiency of the system (that would be a performance test), nor is it a static comparison of test and requirements specification (that would be a review or inspection), nor is it based on the structure of the test object (that would be a structural test).

References:

• Certified Tester Foundation Level Syllabus - ISTQB Guru1, page 10
• Certified Tester Foundation Level (CTFL) Syllabus - ASTQB2, page 65
• A Study Guide to the ISTQB® Foundation Level 2018 Syllabus - Springer3, page 77

The correct answer is B, as it defines risk level correctly. Risk level is determined by the likelihood of an event happening and the impact or harm from that event4. Likelihood is the probability or frequency of the event occurring4. Impact is the severity or consequence of the event occurring4. Risk level can be calculated by multiplying likelihood and impact, or by using a risk matrix that assigns risk levels based on different combinations of likelihood and impact4. Option A is incorrect, as it does not define risk level correctly. Risk level is not calculated by adding the probabilities of all planned risks to a project, but by assessing the likelihood and impact of each individual risk4. Option C is incorrect, as it does not define risk level correctly. Risk level is not calculated by dividing the sum of all known risks by the sum of all unknown risks, but by assessing the likelihood and impact of each individual risk4. Option D is incorrect, as it does not define risk level correctly. Risk level is not determined by calculating the absolute value of the sum of all potential issues that may occur on the project, but by assessing the likelihood and impact of each individual risk4. References: 4, Section 2.8

Functional test is the type of test that is created when a test case is based on a use case. A use case is a description of how a system interacts with one or more actors (users or other systems) to achieve a specific goal or function. A functional test is a test that verifies that a system or software component performs its specified functions according to its requirements. Functional tests can be derived from use cases by identifying test scenarios and test cases that cover the main flow and alternative flows of each use case2 explains this as follows:

Use cases are one of the most commonly used techniques for analyzing and modeling functional requirements for a system. A use case describes how an actor interacts with a system to accomplish a specific goal.

Functional Testing is a type of software testing whereby the system is tested against the functional requirements/specifications. Functions are tested by feeding them input and examining the output.

Use cases can be used as a source for deriving functional tests by identifying test scenarios and test cases that cover the main flow and alternative flows of each use case.

A, C, and D are incorrect answers. Structural test, performance test, and regression test are not types of tests that are created when a test case is based on a use case. Structural test is a type of test that is based on the internal structure and logic of the code rather than the functionality or requirements. Performance test is a type of test that measures the speed, responsiveness, scalability, or stability of a system under various workloads or conditions. Regression test is a type of test that verifies that previously working functionality still works after changes are made to the system or its environment.

According to the syllabus, a software development life cycle (SDLC) model is a conceptual framework that describes the phases and activities involved in developing a software product. Different SDLC models have different advantages and disadvantages depending on the project context and objectives. The principle of early testing states that testing activities should start as early as possible in the software development life cycle and be focused on defined objectives. Early testing helps to prevent defects, reduce rework, lower costs, and improve quality. The answer A is correct because it best exemplifies a model that does not support the principle of early testing. The waterfall model is a sequential SDLC model that divides the development process into distinct phases, such as requirements analysis, design, implementation, testing, and maintenance. Each phase must be completed before the next phase can begin, and there is no overlap or iteration between phases. Testing is done only after the implementation phase, which means that defects are detected late in the development cycle and are more expensive and difficult to fix. The other answers are incorrect because they exemplify models that support the principle of early testing. The V-model is an extension of the waterfall model that emphasizes verification and validation activities at each phase of development. Testing is done in parallel with each corresponding development phase, which means that defects are detected early and feedback is provided to the developers. The incremental development model is an iterative SDLC model that divides the development process into smaller increments or iterations, each delivering a working software product or a subset of features. Testing is done at the end of each iteration, which means that defects are detected early and feedback is provided to the developers. The iterative development model is another iterative SDLC model that repeats the development process for each iteration, with each iteration producing an improved version of the software product or a subset of features. Testing is done throughout each iteration, which means that defects are detected early and feedback is provided to the developers.

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

The correct answer is B, as it categorizes them as entry and exit criteria correctly. Entry criteria are conditions that must be met before testing can begin or continue with a specific activity or phase3. Exit criteria are conditions that must be met before testing can conclude or stop for a specific activity or phase3. The following table shows how each example can be categorized:

Therefore, option B is the correct answer. Options A, C, and D are incorrect, as they do not categorize them as entry and exit criteria correctly. References: 3, Section 2.4

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

If the fault in the code is contained in a small area, then it may cause the system to fail under certain circumstances, resulting in a defect1 . However, this is not a definite consequence, as it depends on whether the fault is executed or not. The other options are not definite consequences of this mistake either. Option A assumes that the system will always fail because of the fault, which may not be true if the fault is never executed or does not affect critical functionality1 . Option C assumes that there will be negative impacts on money, time, or business reputation because of the fault, which may not be true if the defect is minor or does not affect important stakeholders1 . Option D assumes that contractual requirements have not been met by testing because of the fault, which may not be true if testing has fulfilled its objectives and scope according to the contract1 .

Debugging the software to find the reason for defects is not a common objective of testing. Debugging is the process of finding, analyzing, and removing the causes of failures in software. Debugging is usually done by developers after testers have reported defects found during testing. Testing is the process of evaluating software by applying test cases to find defects and provide information on its quality. Testing has several common objectives, such as:

• Providing information on the status of the system, such as its readiness for release, its compliance with requirements, its risks and issues, etc.
• Preventing defects, by applying good practices throughout the software development lifecycle, such as reviews, inspections, static analysis, etc.
• Finding defects in the software, by applying test cases that cover different aspects of the software functionality, quality, performance, security, etc.

Therefore, statement D is not correct.

References: Certified Tester Foundation Level Syllabus, Section 1.1 and 1.2

The order in which the specifications for test cases, test conditions and test procedures are developed as a part of the test development process is as follows:

• Test Condition: A test condition is an item or event of a component or system that could be verified by one or more test cases, such as a function, transaction, feature, quality attribute, or structural element.
• Test Case: A test case is a set of input values, execution preconditions, expected results and execution postconditions, developed for a particular objective or test condition, such as to exercise a particular program path or to verify compliance with a specific requirement.
• Test Procedure: A test procedure is a document providing detailed instructions for the execution of one or more test cases.

Therefore, the correct order is test condition --> test case --> test procedure.

References: [Certified Tester Foundation Level Syllabus], Section 4.2.1 and Glossary

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

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.

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.

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

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

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.

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.

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.

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.

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.

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

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

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

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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

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.

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.

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

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

A limitation in the use of static analysis tools is C. Static analysis tools always generate large numbers of warning messages when applied to new code, even if the code meets coding standards. Static analysis tools are tools that analyze the code or other software artifacts without executing them, and report any defects, errors, vulnerabilities, or violations of coding standards or conventions. Static analysis tools can help to improve the quality and maintainability of the code or other software artifacts. However, static analysis tools also have some limitations, such as generating large numbers of warning messages when applied to new code, even if the code meets coding standards or conventions. This can make it difficult for developers or testers to identify and prioritize the most important or critical issues to fix or address. A detailed explanation of static analysis tools can be found in A Study Guide to the ISTQB® Foundation Level 2018 Syllabus, pages 109-1101.

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

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.

They should be involved in reviewing requirements or user stories as soon as drafts are available is the option that represents good testing practice for testers, irrespective of the software lifecycle model used, because it allows testers to provide early feedback, identify potential defects, and clarify test objectives and scope1 . Early involvement of testers in reviewing requirements or user stories can improve the quality and testability of the software and reduce the cost and effort of testing1 . The other options do not represent good testing practice for testers, irrespective of the software lifecycle model used. Option A is not a good option, because they should start test analysis as early as possible, not when the corresponding development level is complete, to avoid delays and inefficiencies in testing1 . Option C is not a good option, because they should ensure that different test objectives apply to each test level, not the same test objectives, to avoid redundancy and gaps in testing1 . Option D is not a good option, because they should minimize the ratio of development levels to test levels to reduce project costs, but rather balance the development and test levels according to the project needs and risks1 .

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

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

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

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

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