Why testing is required in Go - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is testing important in software development?

Choose the best reason why testing is important when writing software.

A To find and fix errors before users encounter them

B To make the program run faster

C To reduce the size of the program file

D To make the code look more complex

💡 Hint

Think about what happens if bugs are found after users start using the software.

Testing helps catch mistakes early so they can be fixed before the software reaches users, improving quality and reliability.

❓ Predict Output

intermediate

What is the output of this Go test function?

Look at this Go test code. What will it print when run?

Go

package main

import (
	"testing"
)

func Add(a, b int) int {
	return a + b
}

func TestAdd(t *testing.T) {
	result := Add(2, 3)
	if result != 5 {
		t.Errorf("Expected 5 but got %d", result)
	} else {
		println("Test passed")
	}
}

A Compilation error

B Expected 5 but got 6

C Test passed

D No output

💡 Hint

Check what the Add function returns and what the test expects.

The Add function returns 5 for inputs 2 and 3, so the test prints "Test passed".

❓ Predict Output

advanced

What error does this Go test produce?

What error message will this Go test produce when run?

Go

package main

import "testing"

func Divide(a, b int) int {
	return a / b
}

func TestDivide(t *testing.T) {
	_ = Divide(10, 0)
}

A Test passed with no errors

B No output

C Compilation error: missing return statement

D panic: runtime error: integer divide by zero

💡 Hint

Think about what happens when dividing by zero in Go.

Dividing by zero causes a runtime panic error in Go, stopping the program.

🧠 Conceptual

advanced

Which is NOT a benefit of testing?

Choose the option that is NOT a benefit of writing tests for your code.

A Improves code readability automatically

B Ensures code works as expected

C Helps catch bugs early

D Facilitates safe code changes

💡 Hint

Think about what testing can and cannot do for your code.

Testing helps find bugs and verify behavior but does not automatically improve how readable the code is.

🚀 Application

expert

How many test cases are run by this Go test suite?

Given this Go test code, how many test cases will run?

Go

package main

import "testing"

func IsEven(n int) bool {
	return n%2 == 0
}

func TestIsEven(t *testing.T) {
	tests := []struct {
		input int
		expect bool
	}{
		{2, true},
		{3, false},
		{0, true},
		{-4, true},
	}

	for _, test := range tests {
		if result := IsEven(test.input); result != test.expect {
			t.Errorf("For %d expected %v but got %v", test.input, test.expect, result)
		}
	}
}

A 2

B 4

C 0

D 1

💡 Hint

Count how many test cases are defined in the tests slice.

The tests slice contains 4 test cases, so the loop runs 4 times.

Practice

1. Why is testing important in Go programming?

easy

A. It allows the program to use more memory.

B. It makes the program run faster automatically.

C. It removes the need to write comments in code.

D. It helps find bugs early and ensures the program works correctly.

Solution

1. Step 1: Understand the purpose of testing

   Testing is done to find errors or bugs early in the program so they can be fixed before causing problems.

2. Step 2: Recognize the benefit of testing

   By testing, we keep the program working correctly and avoid unexpected failures.

3. Final Answer:

   It helps find bugs early and ensures the program works correctly. -> Option D

4. Quick Check:

   Testing = Find bugs early [OK]

Hint: Testing finds bugs early to keep code safe [OK]

Common Mistakes:

• Thinking testing makes code faster
• Believing testing removes need for comments
• Assuming testing increases memory use

2. Which of these is the correct way to start a test function in Go?

easy

A. func TestExample(t *testing.T) {}

B. func testExample(t *testing.T) {}

C. func ExampleTest(t *testing.T) {}

D. func TestingExample(t *testing.T) {}

Solution

1. Step 1: Recall Go test function naming rules

   Go test functions must start with capitalized 'Test' followed by the test name.

2. Step 2: Match the correct function signature

   The function must accept a pointer to testing.T as parameter.

3. Final Answer:

   func TestExample(t *testing.T) {} -> Option A

4. Quick Check:

   Test functions start with 'Test' [OK]

Hint: Test functions start with capital 'Test' [OK]

Common Mistakes:

• Starting function name with lowercase 'test'
• Swapping 'Test' and 'Example' in name
• Using wrong parameter type

3. What will be the output when running this Go test code?

package main

import (
	"testing"
)

func Add(a, b int) int {
	return a + b
}

func TestAdd(t *testing.T) {
	result := Add(2, 3)
	if result != 5 {
		t.Error("Expected 5")
	}
}

medium

A. Compilation error due to missing main function

B. Test fails with error 'Expected 5'

C. Test passes with no output

D. Test fails with runtime panic

Solution

1. Step 1: Analyze the Add function

   Add returns the sum of two integers. Add(2, 3) returns 5.

2. Step 2: Check the test condition

   The test checks if result != 5. Since result is 5, condition is false, so no error is called.

3. Final Answer:

   Test passes with no output -> Option C

4. Quick Check:

   Correct sum means test passes [OK]

Hint: If condition false, test passes silently [OK]

Common Mistakes:

• Assuming test fails when condition is false
• Thinking missing main causes compile error in tests
• Confusing test output with program output

4. Identify the error in this Go test code:

package main

import "testing"

func TestMultiply(t *testing.T) {
	result := Multiply(2, 3)
	if result != 6 {
		t.Error("Expected 6")
	}
}

medium

A. Missing import for Multiply function

B. Multiply function is not defined anywhere

C. Test function name should be lowercase

D. t.Error should be t.Fail

Solution

1. Step 1: Check if Multiply function exists

   The code calls Multiply but no definition or import is shown for it.

2. Step 2: Understand Go requires defined functions

   Calling an undefined function causes a compile error.

3. Final Answer:

   Multiply function is not defined anywhere -> Option B

4. Quick Check:

   Undefined function causes compile error [OK]

Hint: Undefined functions cause compile errors [OK]

Common Mistakes:

• Thinking import is needed for local functions
• Believing test function names can be lowercase
• Confusing t.Error and t.Fail usage

5. You want to add a test for a new feature that returns the length of a string. Which is the best reason to write this test?

hard

A. To check the feature works correctly and prevent future bugs.

B. To make the program run faster when counting string length.

C. To avoid writing documentation for the feature.

D. To reduce the size of the compiled program.

Solution

1. Step 1: Understand the purpose of feature testing

   Tests confirm that new features behave as expected and help catch bugs early.

2. Step 2: Recognize what tests do not do

   Tests do not improve speed, replace documentation, or reduce program size.

3. Final Answer:

   To check the feature works correctly and prevent future bugs. -> Option A

4. Quick Check:

   Tests ensure correctness and catch bugs [OK]

Hint: Tests prove features work and catch bugs [OK]

Common Mistakes:

• Thinking tests improve performance
• Believing tests replace documentation
• Assuming tests reduce program size