Writing basic test functions in Go

Introduction

Tests help check if your code works correctly. Writing basic test functions lets you find mistakes early and fix them easily.

When you want to check if a function returns the right answer.

When you change code and want to make sure nothing else breaks.

When you want to share your code and prove it works.

When you want to automate checking many parts of your program.

When you want to learn how your code behaves with different inputs.

Syntax

Go

func TestFunctionName(t *testing.T) {
    // test code here
}

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

Use t.Error or t.Fail to mark a test as failed.

Examples

This test checks if the Add function returns 5 when adding 2 and 3.

Go

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

This test checks if IsEven correctly identifies even and odd numbers.

Go

func TestIsEven(t *testing.T) {
    if !IsEven(4) {
        t.Error("4 should be even")
    }
    if IsEven(3) {
        t.Error("3 should not be even")
    }
}

Sample Program

This program defines a simple Add function and a test function TestAdd that checks if adding 2 and 3 gives 5.

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.Error("Expected 5, got", result)
    }
}

Important Notes

Test files must be named with _test.go suffix to be recognized by Go test tool.

Run tests using go test command in the terminal.

Tests should be simple and check one thing at a time.

Summary

Basic test functions start with Test and use *testing.T.

Use t.Error to report failures inside tests.

Run tests with go test to check your code automatically.

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