The scenario written in correct Gherkin format and appropriate for the User Story described is Option D:

Given that three Purchase Orders with a total value of £21.75 have been placed so far this month,

When the Purchasing Manager requests the list of Purchase Orders placed this month,

Then the 3 orders and their total value of £21.75 are displayed.

This scenario correctly uses the Gherkin syntax with Given-When-Then structures that clearly specify the context, the action taken by the user, and the expected outcome, making it directly relevant to the user story’s intent .

Static analysis is used on an Agile project to identify the causes of technical debt through the use of tools. This approach allows teams to detect potential issues in code that could lead to technical debt if not addressed promptly, thus maintaining the health of the codebase as it evolves rapidly in Agile environments .

Maintainability metrics typically used with static analysis include measures that reflect the complexity and understandability of the code, such as Number of Lines of Code (LOC), Number of Function Calls, and Comment Frequency. These metrics help in assessing how easily the software can be understood, modified, and maintained. Mean Time Between Failures (MTBF), on the other hand, is a reliability metric. It measures the time elapsed between inherent failures of a system during operation. MTBF is used to predict the system ' s reliability and is not directly related to the maintainability of the code. Reliability metrics like MTBF would be used in the testing phase to measure the operational reliability of the system rather than during static analysis for maintainability assessment.

Control flow analysis is a technique used to examine the sequence in which instructions or statements are executed within a program. In the given pseudocode, the key aspects to consider are the logical flow and any conditional branches that may lead to unreachable code.

The pseudocode provided is:

Program tax check

BEGIN

yearly := 0

tax := 0

get (monthly)

get (tax_rate)

for I = 1..12 loop

yearly := yearly + monthly

tax := tax - (tax_rate * monthly)

ENDLOOP

salary := monthly * 12

IF salary = yearly THEN

print ( " Salary OK " )

ELSE

print ( " Salary not OK " )

ENDIF

year_tax := salary * tax_rate

IF year_tax = tax THEN

print ( " Tax Problem " )

ENDIF

END tax check

Analysis:

Initialization and Input: yearly and tax are initialized to 0. The program takes monthly and tax_rate as input.

Loop Execution: The loop runs from 1 to 12, accumulating monthly into yearly and adjusting tax accordingly.

Salary Calculation and Check: After the loop, salary is calculated as monthly * 12. The program then checks if salary is equal to yearly. Given the loop accumulates monthly into yearly 12 times, salary will always equal yearly, making the IF salary = yearly condition always true. Thus, the " Salary OK " message will always be printed, and the ELSE branch will never be executed.

Yearly Tax Calculation and Check: year_tax is calculated as salary * tax_rate. Then, it checks if year_tax is equal to tax. However, due to the accumulation and subtraction inside the loop, tax would likely not equal year_tax, making the condition IF year_tax = tax false in most practical scenarios. Therefore, the " Tax Problem " message at line 19 is unlikely to be printed.

Conclusion:

Given this flow, the ELSE block associated with the IF salary = yearly condition (line 15) is unreachable. However, the critical analysis indicates that the code at line 19, which prints " Tax Problem " , is also unreachable due to the logic flow where the condition is rarely true.

Thus, the result is that line 19 is more certainly unreachable.

To achieve decision coverage, each branch of the decision structure in the code must be executed at least once. The code snippet has three branches:

withdrawal-amount < = amount-on-deposit

withdrawal-amount < = $100 AND preferred-customer = true

Default case where the transaction is not authorized

Data set #1 triggers the second branch because the withdrawal amount is not less than the amount on deposit, but it is less than $100, and the user is a preferred customer.

Data set #2 triggers the first branch where the withdrawal amount is equal to the amount on deposit.

Data set #3 tests the condition where the withdrawal amount is less than the deposit amount, but the user is not a preferred customer, triggering the default case.

All decision branches are covered by these test cases, achieving 100% decision coverage.

For a Medium risk mission- or safety-critical system, the best testing approach includes a combination of automated tests, exploratory tests, and manual black-box tests. Option B is the most comprehensive, advocating for automated tests to ensure reliability and repeatability, highly recommending exploratory tests to cover unforeseen scenarios, and recommending manual black-box tests to cover standard use cases. This multifaceted approach ensures thorough testing coverage essential for medium risk, safety-critical systems​​.

Component testing tools, which are often specific to a programming language, are used to automate unit tests (answer C). These tools help to validate the functionality of individual components or units of code in isolation from the rest of the application. While build automation tools are indeed used by developers and are related to continuous integration (answers A and D), and they can facilitate testing at various levels (answer B), component testing tools ' primary purpose is to support the testing of individual components, often through automated unit tests, which can be specific to the language in which the components are written.

The pseudocode provided includes a while loop that adjusts the loop variable a within the loop ' s conditional code block. This adjustment, set a = 5 , occurs when a > 10 . Because the loop checks a <</b> 12 as its continuation condition, and a is reset to 5 repeatedly once it exceeds 10, the loop will execute indefinitely, preventing termination. This creates an infinite loop situation since the condition a <</b> 12 will perpetually remain true once a exceeds 10. This is a critical logic error needing correction for proper execution flow​​.