Cost of bugs at different stages in Testing Fundamentals - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to print the stage where bug fixing is cheapest.

Testing Fundamentals

print('Bug fixing is cheapest during the [1] stage.')

Drag options to blanks, or click blank then click option'

Arequirements

Bdeployment

Cproduction

Dmaintenance

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'production' or 'deployment' because bugs are found there, but fixing is more expensive then.

Fixing bugs early during the requirements stage is cheapest because changes are easier to make before coding starts.

2fill in blank

medium

Complete the sentence to show where bug fixing cost increases significantly.

Testing Fundamentals

Bug fixing cost increases significantly during the [1] phase.

Drag options to blanks, or click blank then click option'

Adesign

Brequirements

Ctesting

Ddeployment

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing 'design' because it is before coding, but cost is lower there.

The testing phase is when bugs are found after coding, so fixing them costs more than earlier stages.

3fill in blank

hard

Fix the error in the code to correctly calculate bug fixing cost multiplier.

Testing Fundamentals

cost_multiplier = 1 if stage == 'requirements' else [1]

Drag options to blanks, or click blank then click option'

A'10'

B10

Cten

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string '10' instead of number 10 causes type errors.

The cost multiplier should be a number, not a string or word. 10 is correct for later stages.

4fill in blank

hard

Fill both blanks to create a dictionary mapping stages to bug fixing costs.

Testing Fundamentals

bug_costs = {'requirements': 1, [1]: 10, [2]: 100}

Drag options to blanks, or click blank then click option'

A'testing'

B'deployment'

C'production'

D'design'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'deployment' instead of 'production' for the highest cost.

Testing costs 10 times more, production costs 100 times more than requirements.

5fill in blank

hard

Fill all three blanks to complete the function that returns bug fixing cost multiplier by stage.

Testing Fundamentals

def get_bug_cost(stage):
    return [1].get(stage, [2]) * [3]

costs = {'requirements': 1, 'testing': 10, 'production': 100}

Drag options to blanks, or click blank then click option'

Acosts

B1

C2

Dcosts.get(stage)

Attempts:

3 left

💡 Hint

Common Mistakes

Using costs.get(stage) inside return without default causes errors if stage missing.

The function uses the costs dictionary, returns 1 if stage not found, and multiplies by 2 as an example factor.

Practice

1. Which stage is generally the cheapest to fix a bug in software development?

easy

A. During the requirements or design phase

B. After the software is released to customers

C. During system testing

D. During user acceptance testing

Solution

1. Step 1: Understand bug fixing costs by stage

   Fixing bugs early, such as during requirements or design, is cheaper because changes are easier to make before coding starts.

2. Step 2: Compare later stages

   Fixing bugs after release or during testing is more expensive due to rework, retesting, and possible customer impact.

3. Final Answer:

   During the requirements or design phase -> Option A

4. Quick Check:

   Early bug fixes cost less = A [OK]

Hint: Fix bugs early in design to save cost [OK]

Common Mistakes:

• Thinking bugs cost the same at all stages
• Assuming fixing bugs after release is cheapest
• Confusing testing phase with design phase

2. Which of the following statements correctly describes the cost trend of fixing bugs?

easy

A. Cost increases as bugs are found later in development

B. Cost remains constant regardless of when bugs are found

C. Cost decreases as bugs are found later in development

D. Cost is highest during requirements gathering

Solution

1. Step 1: Recall cost trend principle

   The cost to fix bugs generally increases the later they are found in the development cycle.

2. Step 2: Evaluate each option

   Cost increases as bugs are found later in development correctly states the cost increases later; others contradict this known fact.

3. Final Answer:

   Cost increases as bugs are found later in development -> Option A

4. Quick Check:

   Later bugs cost more = C [OK]

Hint: Later bug discovery means higher fix cost [OK]

Common Mistakes:

• Choosing cost decreases later
• Assuming cost is constant
• Confusing highest cost stage

3. Consider this simplified cost multiplier for fixing bugs at different stages:
Requirements: 1x, Design: 5x, Testing: 10x, Production: 50x
If a bug costs $100 to fix during requirements, how much will it cost if found in production?

medium

A. $500

B. $1,000

C. $50,000

D. $5,000

Solution

1. Step 1: Identify cost multiplier for production

   The production stage multiplier is 50x the requirements cost.

2. Step 2: Calculate production cost

   Cost = $100 * 50 = $5,000.

3. Final Answer:

   $5,000 -> Option D

4. Quick Check:

   100 * 50 = 5000 [OK]

Hint: Multiply base cost by stage multiplier [OK]

Common Mistakes:

• Multiplying by 10 instead of 50
• Confusing production with testing stage
• Incorrect multiplication

4. A developer wrote this statement:
The cost to fix bugs is the same at all stages of development.
What is wrong with this statement?

medium

A. It correctly states the cost is equal at all stages

B. It ignores that fixing bugs later is more expensive

C. It only applies to bugs found during testing

D. It applies only to minor bugs

Solution

1. Step 1: Understand cost variation by stage

   Bug fixing cost varies and increases the later bugs are found.

2. Step 2: Identify error in statement

   The statement wrongly claims cost is the same at all stages, ignoring this fact.

3. Final Answer:

   It ignores that fixing bugs later is more expensive -> Option B

4. Quick Check:

   Cost varies by stage, not equal [OK]

Hint: Bug fix cost rises later, not constant [OK]

Common Mistakes:

• Agreeing cost is equal always
• Thinking it applies only to testing bugs
• Assuming minor bugs cost same always

5. A company found that fixing a bug during testing costs $2,000, and fixing the same bug after release costs $20,000. If the cost to fix during requirements is $200, what is the approximate cost multiplier increase from requirements to testing and from testing to production?

hard

A. Testing is 5x requirements; production is 20x testing

B. Testing is 10x requirements; production is 5x testing

C. Testing is 10x requirements; production is 10x testing

D. Testing is 20x requirements; production is 10x testing

Solution

1. Step 1: Calculate testing multiplier

   Testing cost / requirements cost = 2000 / 200 = 10x.

2. Step 2: Calculate production multiplier relative to testing

   Production cost / testing cost = 20000 / 2000 = 10x.

3. Final Answer:

   Testing is 10x requirements; production is 10x testing -> Option C

4. Quick Check:

   2000/200=10 and 20000/2000=10 [OK]

Hint: Divide costs stage-wise to find multipliers [OK]

Common Mistakes:

• Mixing up multipliers between stages
• Incorrect division order
• Assuming multipliers are equal to costs