Writing basic test functions in Go - Step-by-Step Execution

Concept Flow - Writing basic test functions

Write test function with prefix Test

↓

Use *testing.T parameter

↓

Call function to test

↓

Check result with if condition

↓

Call t.Error or t.Fail if test fails

↓

Run tests with 'go test'

↓

See pass/fail output

This flow shows how to write a test function in Go, check results, and report failures using the testing package.

Execution Sample

Go

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

A simple test function that checks if Add(2, 3) returns 5 and reports an error if not.

Execution Table

Step	Action	Evaluation	Result
1	Call TestAdd with *testing.T	N/A	Test function starts
2	Call Add(2, 3)	Add returns 5	result = 5
3	Check if result != 5	5 != 5 is false	No error reported
4	Test function ends	N/A	Test passes

💡 Test ends after checking condition; no error means test passes

Variable Tracker

Variable	Start	After Step 2	Final
result	undefined	5	5

Key Moments - 3 Insights

Why must the test function name start with 'Test'?

Go's test runner looks for functions starting with 'Test' to know which functions to run as tests, as shown in step 1 of the execution_table.

What happens if the condition in the if statement is false?

If the condition is false (like in step 3), t.Error is not called, so the test passes silently.

Why do we pass *testing.T as a parameter?

The *testing.T parameter provides methods like Error to report failures, as used in step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after step 2?

A 5

B undefined

C 0

D error

💡 Hint

Check the 'Evaluation' and 'Result' columns in row 2 of the execution_table.

At which step does the test report an error if the result is wrong?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Evaluation' columns in step 3 where the condition is checked.

If the Add function returned 4 instead of 5, what would happen in the execution_table?

A Test function would not run

B Step 3 condition would be true and t.Error called

C Step 2 would fail to assign result

D Test would pass anyway

💡 Hint

Refer to step 3 where the condition checks if result != 5.

Concept Snapshot

func TestXxx(t *testing.T) {
  result := FunctionToTest(args)
  if result != expected {
    t.Error("message", result)
  }
}
Run tests with 'go test' command.

Full Transcript

In Go, test functions must start with 'Test' and take a *testing.T parameter. Inside, you call the function you want to test and check its result. If the result is not what you expect, call t.Error to report failure. The test runner runs all such functions and shows pass or fail. This example tests Add(2,3) expecting 5. The execution steps show calling the test, running Add, checking the result, and passing the test if no error is reported.

Practice

1. Which of the following is the correct way to start a basic test function in Go?

easy

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

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

C. func testExample() {}

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

Solution

1. Step 1: Understand Go test function naming

   Test functions must start with 'Test' and take a '*testing.T' parameter.

2. Step 2: Check each option

   Only func TestExample(t *testing.T) {} matches the required signature and naming convention.

3. Final Answer:

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

4. Quick Check:

   Test function starts with 'Test' and uses '*testing.T' [OK]

Hint: Test functions start with 'Test' and accept '*testing.T' [OK]

Common Mistakes:

• Not starting function name with 'Test'
• Missing '*testing.T' parameter
• Using lowercase 'test' prefix

2. Which line correctly reports a test failure inside a Go test function and continues execution?

easy

A. t.Fail()

B. t.Error("failure message")

C. t.Fatal("failure message")

D. t.Log("failure message")

Solution

1. Step 1: Understand failure reporting methods

   Both t.Error and t.Fatal report failures, but t.Error reports and continues, t.Fatal stops immediately.

2. Step 2: Identify the correct method for reporting failure

   t.Error is commonly used to report a failure without stopping the test immediately.

3. Final Answer:

   t.Error("failure message") -> Option B

4. Quick Check:

   Use t.Error to report failure inside tests [OK]

Hint: Use t.Error to report test failures without stopping [OK]

Common Mistakes:

• Using t.Log which only logs info
• Using t.Fail without message
• Confusing t.Fatal with t.Error

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

func TestSum(t *testing.T) {
    total := 2 + 2
    if total != 4 {
        t.Error("Sum is incorrect")
    }
}

medium

A. Test fails with message 'Sum is incorrect'

B. Syntax error prevents test from running

C. Test passes with no output

D. Test panics at runtime

Solution

1. Step 1: Analyze the test logic

   The sum 2 + 2 equals 4, so the condition 'total != 4' is false and t.Error is not called.

2. Step 2: Understand test output behavior

   Since no error is reported, the test passes silently with no failure message.

3. Final Answer:

   Test passes with no output -> Option C

4. Quick Check:

   Correct sum means no error reported [OK]

Hint: If condition is false, t.Error is not called, test passes [OK]

Common Mistakes:

• Assuming test fails when condition is false
• Confusing test output with print statements
• Thinking syntax error exists when code is correct

4. Identify the error in this test function:

func TestCheck(t *testing.T) {
    if 1 == 1 {
        t.Error("Test failed")
    }
}

medium

A. The test always fails because condition is always true

B. Missing *testing.T parameter in function

C. Function name does not start with 'Test'

D. t.Error should be t.Fail

Solution

1. Step 1: Analyze the condition inside the test

   The condition '1 == 1' is always true, so t.Error is always called.

2. Step 2: Understand test failure consequence

   Because t.Error is called unconditionally, the test always fails, which is likely a logic error.

3. Final Answer:

   The test always fails because condition is always true -> Option A

4. Quick Check:

   Always true condition causes test failure [OK]

Hint: Check if test condition wrongly always triggers failure [OK]

Common Mistakes:

• Ignoring always true condition
• Confusing t.Error and t.Fail usage
• Overlooking function naming correctness

5. You want to write a test function that checks if a function Multiply(a, b int) int returns the correct product. Which test function correctly tests this with failure reporting?

hard

A. func TestMultiply() {
if Multiply(3, 4) != 12 {
t.Error("Expected 12")
}
}

B. func TestMultiply(t *testing.T) {
if Multiply(3, 4) != 7 {
t.Error("Expected 7")
}
}

C. func TestMultiply(t *testing.T) {
if Multiply(3, 4) == 12 {
t.Error("Expected 12")
}
}

D. func TestMultiply(t *testing.T) {
if Multiply(3, 4) != 12 {
t.Error("Expected 12")
}
}

Solution

1. Step 1: Check function signature and parameter

   Test functions must have signature func TestX(t *testing.T). Only options B, C, and D have this.

2. Step 2: Verify test logic correctness

   func TestMultiply(t *testing.T) { if Multiply(3, 4) != 12 { t.Error("Expected 12") } } checks if Multiply(3,4) != 12 and reports error if true, which is correct. func TestMultiply(t *testing.T) { if Multiply(3, 4) == 12 { t.Error("Expected 12") } } wrongly reports error if result equals 12. func TestMultiply(t *testing.T) { if Multiply(3, 4) != 7 { t.Error("Expected 7") } } expects 7, which is incorrect.

3. Final Answer:

   func TestMultiply(t *testing.T) { if Multiply(3, 4) != 12 { t.Error("Expected 12") } } -> Option D

4. Quick Check:

   Correct signature and logic test for Multiply [OK]

Hint: Test functions need correct signature and proper condition [OK]

Common Mistakes:

• Missing *testing.T parameter
• Wrong expected value in condition
• Inverted condition causing false failures