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

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

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

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

!decision table

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

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

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

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

 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.

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

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

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

References:  Certified Tester Foundation Level Syllabus , Section 2.2

Maintenance testing is important after migration, retirement or enhancement of an existing system. defines maintenance testing as follows:

Maintenance testing is a type of software testing that occurs after changes have been made to a system in order to ensure that no new defects have been introduced and that the system still meets its original requirements and specifications.

Regression testing (A) is important after any change in the system that may affect existing functionality. Operational acceptance testing (B) is important before deploying a system into production environment. System testing © is important after integrating all components of a system into a complete system.

The correct logical order for the test cases is 3, 1, 4, 2, 6, 5. This order follows the logical sequence of actions that a user would perform to book a flight using a web-based airline booking system. The order also respects the dependencies between test cases, such as logging in before searching for flights or booking a flight before printing a confirmation receipt . The other options are incorrect logical orders for the test cases. Option A does not follow the logical sequence of actions and does not respect the dependencies between test cases. For example, it starts with confirming details and booking a flight before logging in or selecting a flight. Option B does not follow the logical sequence of actions and does not respect the dependencies between test cases. For example, it starts with selecting a flight before logging in or searching for flights. Option C does not follow the logical sequence of actions and does not respect the dependencies between test cases. For example, it starts with viewing selected items in My Flights before selecting any flights.

The combination of the conditions Valid Card Number (NO) + Purchase Approved (YES) is not feasible, as a purchase cannot be approved with an invalid card number. Therefore, this combination can be ignored in the equivalence partitioning for the different types of credit card. Each type of credit card has two valid equivalence partitions: Valid Card Number (YES) + Purchase Approved (YES) and Valid Card Number (YES) + Purchase Approved (NO). Each type of credit card also has one invalid equivalence partition: Valid Card Number (NO) + Purchase Approved (NO). Therefore, to cover all the combinations of equivalence partitions for the four types of credit card, we need 4 x (2 + 1) = 12 test cases.

A, B, and D are incorrect answers. A implies that there are two equivalence partitions for each type of credit card, which is not true as there are three. B implies that there is only one equivalence partition for each type of credit card, which is not true as there are two valid ones and one invalid one. D implies that there are four equivalence partitions for each type of credit card, which is not true as there are only three.

A unit test framework tool is a tool that supports the creation, execution and reporting of unit tests, which are tests that verify the functionality and quality of individual functions or methods in source code. A unit test framework tool can detect defects such as syntax errors, logic errors, boundary violations, etc.

The general principles of testing state that testing can show the presence of defects, but not their absence. Running the same test set more often will not increase the likelihood of finding new defects, unless the system or its environment changes. Therefore, statement A contradicts the general principles of testing. Statement B is true, as testing is context-dependent and should be tailored to the specific situation of a project. Statement C is also true, as early testing can help prevent defects and reduce rework. Statement D is true, as it reflects the Pareto principle or the 80/20 rule, which states that most defects are found in a small subset of a system’s modules.

References: ISTQB Certified Tester Foundation Level Syllabus 2018, Section 1.2

The user interface being complicated and confusing is not an appropriate part of an incident report covering the observation of a failure during testing, as it is a subjective opinion and not a factual description of the failure.  An incident repor t should include objective and relevant information that can help to identify, reproduce, and resolve the failure 3  defines an incident report as follows:

An incident report is a document that records the occurrence of an abnormal or unexpected event during testing, such as a deviation from expected results, a defect in the system under test, or a problem in the test environment. An incident report typically includes the following information:

Identifier: A unique identifier for the incident report.

Summary: A brief description of the incident.

Incident details: A detailed description of the incident, including the inputs, expected results, actual results, environment, date and time, severity, priority, and any other relevant information.

Steps to reproduce: A sequence of steps that can be followed to reproduce the incident.

Attachments: Any screenshots, logs, files, or other artifacts that can help to understand or reproduce the incident.

A test completion report for a test level typically includes a summary of all the testing activities that have been performed. It should detail any deviations from the original test schedule, including any changes in the planned duration or effort that were required to complete the test activities. This report serves as a record of what was tested, how it was tested, and any issues that were encountered.

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

Static testing can prevent defects later in design and coding by uncovering issues in requirements 1 .  This is the best statement of the value of static te sting, as it can save time and money by finding defects early in the development process 1 .  Option B is incorrect, as static testing is most effective when performed before dynamic testing 1 .  Option C is incorrect, as static testing can detect different types of defects than those found by dynamic testing, such as inconsistencies, a mbiguities, omissions, and incompleteness 1 .  Option D is incorrect, as static testing can improve team member communication by facilitating reviews and inspections 1 . References:  1 , Section 3.1

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

The testability of requirements is evaluated during the Test Analysis and Design stage of the fundamental test process 3 . The fundamental test process consists of five main activities:

Test Planning and Control: This activity involves defin ing the scope, objectives, approach, and resources for testing, as well as monitoring and controlling the test progress and results 3 .

Test Analysis and Design : This activity involves analyzing the test basis (such as requirements, design, etc.) and designing the test cases, procedures, and environment 3 .  The testabi lity of requirements is evaluated during this activity, as it involves checking the clarity, completeness, consistency, and testability of the requirements 3 .

Test Implementation and Execution: This activity involves implementing the test cases and procedures, preparing the test environment and data, executing the test cases, and logging the test results and incidents 3 .

Evaluating Exit Criteria and Reporting: This activity involves evaluating the test results against the exit criteria (such as coverage, defect rate, etc.) and reporting the test status and outcomes to the stakeholders 3 .

Test Closure Activities: This activity involves finalizing the test documentation, archiving the test artifacts, evaluating the test proce ss and lessons learned, and releasing the test resources

The predicted number of defects and the amount of rework required is the most likely fac tor to impact the amount of testing effort required, because it affects the quality and stability of the software under test 1  .  Testing effort can increase if there are many defects in the software that need to be detected, reported, fixed, and re-tested 1  . The other options are not likely to impact the amount of testing effort required directly.  Option B is related to the size and composition of the project team, but it does not determine how much testing effort is needed for the software itself 1  .  Option C is related to the use of a project management tool to schedule tasks, but it does not affect how much testing effort is needed for each task 1  .  Option D is related to the responsibilities for testers and developers being clearly defined, but it does not influence how much testing effor t is needed for their respective tasks 1  .

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

A test execution tool is a tool that executes tests on a software system and logs the outcomes of each test step. The ability of the tool to run the unit-level tests for the developers is one of the factors that should be considered when purchasing a test execution tool, as it can improve the efficiency and effectiveness of testing at this level. The other options are not relevant to test execution tools, but to other types of tools such as test management tools, test measurement tools, and requirements management tools. References:  Section 6.1.1 ,  Section 6.3.2

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

Gaining in-depth knowledge about the tool, understanding both its strengths and weaknesses

Evaluating how the tool fits with existing processes and practices, and determining what would need to change

Assessing whether the benefits will be achieved at reasonable cost

Identifying and resolving any technical and organizational issues before deploying the tool on a larger scale

Providing training, coaching, and mentoring for users of the tool

Defining metrics to measure the success of the tool deployment

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

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

To establish whether the tool is available for a free trial period (and for how long) (A).  This is part of the tool selection process, which involves gathering information about the tool features, costs, support, and availability 1 2 .  This should be done before running a pilot project, as it helps to narrow down the list of potential tools and to conduct a proof-of-concept 1 2 .

To provide training, coaching, and mentoring for users of the tool (B).  This is an outcome of the pilot project, which aims to increase the competence and confidence of the tool users and to facilitate the tool adoption 1 2 .  This should be done during and after the pilot project, as it helps to ensure the effective and efficient use of the tool and to address any issues or feedback from the users 1 2 .

To develop a clear set of requirements and objective criteria against which the tool can be evaluated ©.  This is also part of the tool selection process, which involves defining the tool requirements based on the needs and expectations of the stakeholders, and establishing the evaluation criteria based on the benefits and risks of the tool 1 2 .  This should also be done before running a pilot project, as it helps to compare and rank the potential tools and to select the most suitable one 1 2 .

References :

ISTQB Foundation Level 2018 syllabus

Chapter 6 - Tool Support for Testing | PPT

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

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

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

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

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

According to the syllabus, the absence-of-errors fallacy is a common misconception that finding and fixing defects will ensure the success of a system. This fallacy ignores the fact that there may be other factors that affect user satisfaction and system value, such as usability, functionality, performance, reliability, security, etc. The answer D is correct because it is an example of the absence-of-errors fallacy. Since testing found very few defects, the system certainly will be successful. This statement assumes that defect detection is the only criterion for system success, which is not true. The other answers are incorrect because they are not examples of the absence-of-errors fallacy, but rather facts or challenges related to testing.

References: [Certified Tester Foundation Level Syllabus], Section 1.2.1, page 11.

The correct matching of the review types with the review characteristics is as follows:

Pair review: Informal (2)

Walkthrough: Purpose includes gaining consensus (3)

Technical review: Purposes include improving the software product and training the review participants (4)

Inspection: Formal (1)

Therefore, option C is the correct answer. Options A, B, and D are incorrect, as they do not match the review types with the review characteristics correctly.

References: Section 3.2.1

To be based on an analysis of the structure of the component or system. White box testing techniques are based on the internal structure and code of the system, not on its specifications or functionality. White box testing techniques include statement coverage, decision coverage, branch coverage, path coverage, etc. White box testing techniques are usually performed at lower levels of testing, such as unit testing or component testing. A detailed explanation of white box testing techniques can be found in [A Study Guide to the ISTQB® Foundation Level 2018 Syllabus], pages 68-74.

  The percentage of planned test cases designed is not a common metric used for monitoring test preparation and execution, because it does not refle ct the quality or completeness of the test cases or their alignment with the test objectives 1  . The other options are common metrics used for monitoring test preparation and execution.  The number of test cases passed and failed indicates the quality and status of the software under test 1  .  The number of test plan review comments indicates the quality and completeness of the test plan document 1  .  The percentage of tasks complete in test environment preparation indicates the progress and readiness of the test environment 1  .

Component testing is concerned with testing the smallest bodies of software, such as functions, classes, procedures, or modules. Component testing is also known as unit testing or module testing. Feature testing is a type of functional testing that focuses on verifying a specific feature or functionality of a system. Functional testing is a type of black-box testing that verifies that the system meets its functional requirements and specifications. Subsystem testing is a type of integration testing that verifies that a group of components work together as expected. References: ISTQB Certified Tester Foundation Level Syllabus 2018, Section 2.2

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 correct answer is D, as it describes a task that is most likely to be performed by the tester.  A tester is a person who performs testing activities such as planning, designing, executing, and evaluating tests 2 .  Creating the detailed test execution schedule is one of these activities, as it involves defining the order and timing of test cases to be executed based on various factors such as dependencies, risks, priorities, and resources 2 . Option A is incorrect, as it describes a task that is most likely to be performed by the test manager.  A test manager is a person who leads and manages testing activities such as establishing test policies and strategies, managing test teams and stakehol ders, monitoring and controlling test progress and quality, and reporting on test results 2 .  Developing a test strategy and test policy for the organization is one of these activities, as it involves defining the overall approach and objectives for testing at an organizational level 2 . Option B is incorrect, as it describes a task that is most likely to be performed by the test analyst.  A test analyst is a pers on who supports testing activities such as analyzing requirements and risks, designing and prioritizing tests, evaluating test coverage and traceability, and reviewing work products 2 .  Introducing suitable metrics for measuring test progress is one of these activities, as it involves defining and collecting quantitative data to monit or and control various aspects of testing such as efficiency, effectiveness, quality, and maturity 2 . Option C is incorrect, as it describes a task that is most likely to be performed by the test leader.  A test leader is a person who coordinates testing activities such as planning and estimating tests, allocating tasks and resources, supervising test execution and evaluation, communicating with stakeholders, and resolving issues 2 .  Promoting and advocating the test team within the organization is one of these activities, as it involves demonstrating the value and benefits of testing to other partie s such as management, developers, customers, and users 2 . References:  2 , Section 2.3

UAT stands for user acceptance testing, which is a type of testing t hat verifies that the software product meets the acceptance criteria and expectations of the end users or customers 1 .  A UAT specification is a document that defines the scope, objectives, approach, and criteria for UAT 1 .  Testers should be involve d 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 requirements 1 .  Testers can also provide feedback and suggestion s to improve the UAT specification and avoid potential issues or conflicts during UAT execution 1 . Therefore, testers should be involved in reviewing a UAT specification at any time before UAT begins.

The goal of statement testing is to increase the percentage of executable statements that are exercised by a test set.  This is also known as statement coverage or line coverage 3  defines this as follows:

Statement Coverage (also known as Line Coverage) measures how many statements have been executed by your tests. It’s calculated by dividing the number of executed statements by total number statements in source code file.

Statement testing does not aim to reduce the number of tests needed to test the system (A), assess the correctness of key statements in each module of the application (B), or assess the number of code statements needed to implement each feature (D).

Finding the root cause of a defect is not a major responsibility of a tester. Finding the root cause of a defect is usually done by developers who have access to the source code and can debug it to identify and fix the defect.  Testers are responsible for reporting and tracking defects, but not for finding their root causes 2  states this as follows:

The role of testers is to find defects in software products and report them to developers who are responsible for fixing them. Testers do not need to know how to fix defects or find their root causes, as this requires access to the source code and debugging skills that are typically possessed by developers.

A, C, and D are incorrect answers. Producing interim test reports, writing the test specification, and reporting and tracking bugs are major responsibilities of a tester. Producing interim test reports is part of test monitoring and control, which involves measuring and evaluating test progress and quality against objectives and criteria. Writing the test specification is part of test analysis and design, which involves identifying test conditions based on test basis and designing test cases based on test techniques. Reporting and tracking bugs is part of test implementation and execution, which involves logging incidents when observed outcomes deviate from expected outcomes and tracking their status until closure.

Component integration testing is the process of testing the interactions between different components of a system. It should always be done before system testing, which is the process of testing the system as a whole. Integration testing can reveal defects in the interfaces and interactions between components, which can affect the functionality and performance of the system. System testing can reveal defects in the system requirements, design, and behavior, which can affect the quality and usability of the system. Therefore, it is logical to perform integration testing before system testing, to ensure that the components work together correctly before testing the system as a whole.

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

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

  Frequency 0, 1, 5, 6; Duration 0, 1, 30, 60, 61 is the correct test set of valid and invalid boundary values applying 2-value boundary value analysis 1  .  Boundary value analysis is a technique that tests the values at and near the boundaries of an input do main or output range 1  .  A 2-value boundary value analysis tests two values for each boundary: one valid value and one invalid value 1  . For Frequency, the valid boundaries are 1 and 5, so the test set should include one valid value (1 or 5) and one invalid value (0 or 6) for each boundary. For Duration, the valid boundaries are 1 and 60, so the test set should include one valid value (1 or 60) and one invalid value (0 or 61) for each boundary. The other options are incorrect test sets of valid and invalid boundary values applying 2-value boundary value analysis. Option A only includes valid values for each boundary, but not invalid values. Option B includes invalid values that are not adjacent to the boundaries (59 seconds and 60 minutes 1 second). Option D includes more than two values for each boundary (0, 1, 2 for Frequency; 0, 1, 30 for Duration).

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

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.

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 req uirement 1  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.

  Equivalence partitioning is a black box test design technique 2 .  A black box technique is a technique that uses the external behaviour or specification of a system as a test basis to derive test cases without referring to its internal structure or logic 2 .  Equivalence partitioning is a technique that divides the input domain of a system into partitions of equivalent data 2 .  Each partition should contain data that is expected to be treated the same by the system 2 .  Th erefore, only one test case input from each partition is needed to test the system’s behaviour 2 . Therefore, equivalence partitioning is a black box test design technique.

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.

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

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.

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

Software testers have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company. They can also use tools and techniques to support their testing activities and provide reliable and objective information about the quality and risk level of each candidate application.

Experts from the accounting department have the knowledge and expertise to understand and validate the functionality and usability of each candidate application. They can also provide feedback and suggestions for improvement based on their needs and expectations as end users or customers.

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

A team from an outsourcing company which specializes in testing accounting software: This team might have the skills and experience to test accounting software, but they might not have the knowledge and expertise to understand and validate the specific requirements and criteria of the company that wants to buy the application. They might also lack the communication and collaboration with the stakeholders of the company who are involved in the evaluation process.

A team of users from the accounting department that will need to use the application on a daily basis: This team might have the knowledge and expertise to understand and validate the functionality and usability of each candidate application, but they might not have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company. They might also lack the tools and techniques to support their testing activities and provide reliable and objective information about the quality and risk level of each candidate application.

A team from the company’s testing team, due to their experience in testing software: This team might have the skills and experience to design, execute, and evaluate test cases based on the requirements and criteria of the company, but they might not have the knowledge and expertise to understand and validate the functionality and usability of each candidate application. They might also lack the feedback and suggestions for improvement based on the needs and expectations of the end users or customers.

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.

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

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

Variables that are never used: This defect type occurs when a variable is declared but not referenced or assigned in the code, which indicates a waste of memory or a logic error.

Coding standard violations: This defect type occurs when the code does not follow the predefined rules or conventions for formatting, naming, commenting, etc., which affects the readability and maintainability of the code.

Uncalled functions and procedures: This defect type occurs when a function or procedure is defined but not called or invoked in the code, which indicates a waste of resources or a missing functionality.

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

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

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

I. Generally, decision tables are generated for low risk test items: This statement is false because decision tables can be generated for any level of risk test items depending on the complexity and variability of the system under test. Decision tables are especially useful for testing systems that have many inputs, outputs, conditions, and rules that affect their behavior or performance.

II. Test cases derived from decision tables can be used for component tests: This statement is true because decision tables can be used to design test cases for any level or type of testing, including component tests. Component tests are tests that verify individual components or units of software in isolation from other components or systems.

III. Several test cases can be selected for each column of the decision table: This statement is true because each column of the decision table represents a unique combination of inputs and outputs for the system under test based on certain conditions and rules. Therefore, each column can be used as a basis for selecting one or more test cases that cover that combination.

IV. The conditions in the decision table represent negative tests generally: This statement is false because the conditions in the decision table can represent both positive and negative tests depending on the requirements and expectations of the system under test. Positive tests are tests that verify that the system under test behaves as expected under valid or normal inputs or conditions. Negative tests are tests that verify that the system under test handles errors or exceptions gracefully under invalid or abnormal inputs or conditions.

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

The 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 T ester Exam , Chapter 2, Section 2.1 2 .

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

Percentage of work done in test environment creation: This metric indicates how much effort has been spent on setting up and maintaining the test environment, which includes hardware, software, network, data, tools, etc., that are required for conducting the test activities.

Number of test cases run: This metric indicates how many test cases have been executed during a given period or phase of testing.

Deviation from test milestone dates: This metric indicates how much delay or ahead of schedule the test activities are compared to the planned dates.

Defect density: This metric indicates how many defects have been found per unit of size or functionality of the system under test.

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

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® Foundatio n Level 2018 Syllabus , Chapter 2 1 .

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 , Chapt er 3 1 .

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

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.

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

UC1: Add a new borrower to the system

UC2: Update a borrower’s data

UC3: Remove a borrower from the system

UC4: Loan a book to a borrower

UC5: Return a book from a borrower

UC6: Reserve a book for a borrower

UC7: Send “reservation ready” message to a borrower

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

TC1: Add a new borrower to the system - > This is the first step of the use case, where the user registers as a new borrower in the system.

TC2: Update a borrower’s data - > This is a possible variation of the use case, where the user updates their personal or contact information in the system.

TC6: Reserve a book for a borrower - > This is the second step of the use case, where the user reserves a book that they want to borrow from the library.

TC7: Send “reservation ready” message to a borrower - > This is the third step of the use case, where the system sends a message to the user informing them that their reserved book is ready for pickup.

TC4: Loan a book to a borrower - > This is the fourth step of the use case, where the user picks up their reserved book from the library and loans it from the system.

TC5: Return a book from a borrower - > This is the fifth step of the use case, where the user returns their borrowed book to the library and returns it to the system.

TC3: Remove a borrower from the system - > This is a possible exception of the use case, where

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

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

A. 1-4-2-7-5-6-3 - > This test sequence does not follow the logical order and flow of the user-system interaction because it performs some steps before or after they are supposed to happen. For example, it performs TC4 (Loan a book to a borrower) before TC6 (Reserve a book for a borrower), which does not make sense because the user cannot loan a book that they have not reserved yet.

B. 1-6-2-5-7-4-3 - > This test sequence does not follow the logical order and flow of the user-system interaction because it performs some steps before or after they are supposed to happen. For example, it performs TC5 (Return a book from a borrower) before TC4 (Loan a book to a borrower), which does not make sense because the user cannot return a book that they have not loaned yet.

C. 1-6-4-7-5-3-2 - > This test sequence does not cover the main scenario and possible variations or exceptions because it omits some steps that are essential for completing or terminating the use case. For example, it omits TC2 (Update a borrower’s data), which is a possible variation of the use case that allows the user to change their personal or contact information in the system.

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

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

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 I STQB® Foundation Level 2018 Syllabus , Chapter 3, Section 3.2 1 .

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

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

Finding defects: Testing is the process of finding defects or failures in the software product that do not meet its requirements or expectations.

Providing information for decision-making: Testing is the process of providing information about the quality and risk level of the software product based on the observed behavior and results under certain conditions and assumptions. This information can help stakeholders make informed decisions about releasing, deploying, accepting, or improving the software product.

Gaining confidence about the level of quality of the software: Testing is the process of gaining confidence that the software product meets its requirements and expectations and provides value to the users and customers.

Analyzing and removing the cause of failures: Testing is not only the process of finding defects but also the process of analyzing and removing the cause of failures that lead to defects. This objective is related to debugging, which is a development activity that involves locating, diagnosing, and fixing errors in the code or design of the software product.

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

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

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

Defect ID: A unique identifier for the defect

Summary: A brief description of the defect

Severity and priority: An indication of how serious and urgent the defect is

Test environment details: A description of the hardware, software, network, data, tools, etc., that were used when the defect was found

How to reproduce the defect: A step-by-step procedure to recreate the defect

Expected and actual results: A comparison of what should have happened and what actually happened when the defect occurred

Attachments: Any additional information or evidence that can help understand or resolve the defect, such as screenshots, logs, files, etc.

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

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

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

Characteristics of the product: This factor indicates how difficult or challenging it is to test the software system based on its size, functionality, reliability, usability, performance, security, etc.

Characteristics of the development process: This factor indicates how well or poorly the software system is developed based on the development methodology, standards, tools, techniques, etc.

Characteristics of the test process: This factor indicates how effective or efficient the testing process is based on the test strategy, plan, design, execution, evaluation, etc.

Characteristics of the test team: This factor indicates how skilled or experienced the test team is based on their knowledge, competence, motivation, communication, collaboration, etc.

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

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.

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 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 2 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 4 1 .

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

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

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

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

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 , Ch apter 4, Sections 4.2 and 4.3 1 .

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.

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

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.

 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

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

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

True branch: If Gender = ‘female’, then print “Ms” at line 5.

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

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

TC1: Gender = ‘female’ - > Print “Dear Ms”

TC2: Gender = ‘male’ - > Print “Dear Mr”

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

A. 1: This option is not enough because it only provides one test case that covers one outcome or branch of the decision point, but not the other.

C. 3: This option is too many because it provides three test cases that cover both outcomes or branches of the decision point, but one of them is redundant or unnecessary.

D. 4: This option is too many because it provides four test cases that cover both outcomes or branches of the decision point, but two of them are redundant or unnecessary.

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

Test cases derived from the knowledge of the testers and the knowled ge of testers, developers and users are used to drive testing apply to experience-based techniques 1 .  Experience-based techniques are techniques that use the skill, intui tion, and experience of testers, developers, and users to derive test cases, using error guessing and exploratory testing 1 .  Error guessing is a technique that uses common sense and previous experience to guess where defects might occur in a system 1 .  Exploratory testing is an approach that involves simultaneous learning, test design, and test execution 1 .  Experience-based techniques are typically used when there is insufficient information or time to apply other more formal techniques 1 . Therefore, test cases derived from the knowledge of the testers and the knowledge of testers, developers and users are used to drive testing apply to experience-based techniques.

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.

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 testing 1 .  Error guessing is a technique that uses common sense and previous experience to guess where defects might occur in a system 1 .  Exploratory testing is an approach that involves simultaneous learning, test design, and test execution 1 .  Experience-based test design techniques are typically used when there is insufficient information or time to apply other more forma l techniques 1 . 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.

  S2 and O2 are the finishing state and the output(s) from the test case 1 . 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.

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.

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

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

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

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 Syllabu s , pages 61-67 1 .

(0, 12, 13,18,19) represent boundary values for the age groups. Boundary value analysis is a technique to test the values at the boundaries of an input domain or equivalence partition. explains this as follows:

Boundary value analysis (BVA) is based on testing the boundary values of valid and invalid partitions. The behavior at the edge of each equivalence partition is more likely to be incorrect than the behavior within the partition, so boundaries are an area where testing is likely to yield defects.

(-1,0,11,12,13,14,18,19) (B) are not boundary values, but include some boundary values and some non-boundary values. (4,5,15,20) © are not boundary values at all. (-1.0,12,13,18,19) (D) are not boundary values either, as -1.0 is not an integer value.

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

Re-prioritizing tests because of time pressure

Changing the test schedule due to availability of a test environment

Setting entry and exit criteria for test levels or test activities

Initiating corrective actions to resolve deviations from the test plan

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

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

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

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

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.

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

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

Concerned with the behavior of a whole system/product as defined by the scope of a development project. System testing is a level of testing that evaluates the system as a whole against its requirements and specifications. System testing is performed after integration testing and before acceptance testing. System testing covers functional and non-functional aspects of the system, such as usability, performance, reliability, security, etc. A detailed explanation of system testing can be found in  A Self-Study Guide For The ISTQB Foundation Exam Cert ified Tester Foundation Level (CTFL) 2018 Syllabus , pages 75-78 2 .

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

Functional testing to test security at the system level: This type of testing verifies that the software product performs its intended functions according to the user requirements and expectations 1 .  Security is one of the functional aspects that needs to be tested at the system level, as it ensures that the software product p rotects itself from unauthorized access or harm 1 .

Load testing at the system level to ensure the system availabili ty is acceptable: This type of testing verifies that the software product can handle the expected or peak load of users or transactions without degrading its performance or functionality 1 .  Availability is one of the quality attributes that needs to be tested at the system level, as it measures how well the software product performs its intended functions under specifi ed conditions without interruption or failure 1 .

Regression testing at all levels: This type of testing verifies th at previously tested software still performs correctly after changes or defect corrections 1 .  Regression testing is required at all levels of testing, as changes or defect corrections can introduce new defects or affect existing functionality 1 .

Structure based testing at the component level only: This type of testing uses the structure or logic of the source code as a test basis to derive test cases and measure test coverage 1 .  Structure based testing is required at the component level only, as the test manager has decided that the code should be thoroughly tested at component level to ensure its quality and reliability 1 .

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 suite 1 .  Decision coverage is a criterion that requires every decision (or branch) in the source co de to take both true and false outcomes at least once by a test suite 1 . 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.

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  Softwar e Testing Foundations: A Study Guide for the Certified Tester Exam , pages 193-198 3 .

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

Use-case testing is a technique that uses use-cases as a test basis to derive test cases 2 .  A use-case is a descrip tion of interactions between actors and a system to achieve a goal 2 .  An actor represents a type of user or anythin g that interacts with the system 2 .  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 testing 3 .  An actor is not always a human user, as it can also be another system or device 2 .  Test cases can be based on use-case scenarios, which are sequences of actions and events that occur during a use-case execution 2 . 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.