Golang Code Coverage And Profiling Complete Guide

Code Coverage

Step 1: Write a Simple Program

Create a file named math.go with some basic functions for testing:

package math

// Add takes two integers and returns their sum.
func Add(x int, y int) int {
    return x + y
}

// Multiply takes two integers and returns their product.
func Multiply(x int, y int) int {
    return x * y
}

Step 2: Write Test Cases

Create a test file named math_test.go:

package math

import "testing"

func TestAdd(t *testing.T) {
    sum := Add(2, 3)
    if sum != 5 {
        t.Errorf("Add was incorrect, got: %d, want: %d.", sum, 5)
    }
}

func TestMultiply(t *testing.T) {
    product := Multiply(4, 5)
    if product != 20 {
        t.Errorf("Multiply was incorrect, got: %d, want: %d.", product, 20)
    }
}

Step 3: Run Tests with Coverage

Open your terminal, navigate to the directory containing math.go and math_test.go, and run the following command:

go test -coverprofile=coverage.out

This command will generate a coverage report and save it to coverage.out.

Step 4: View Coverage Report

You can view the code coverage in your terminal using:

go tool cover -func=coverage.out

Alternatively, you can generate an HTML coverage report which is more readable:

go tool cover -html=coverage.out -o coverage.html

This will create a file named coverage.html. You can open this file in any web browser to see the detailed coverage report.

Step 5: Improve Coverage

To ensure better coverage, add more test cases or scenarios. For example:

// New test case for the Add function with negative numbers
func TestAddNegativeNumbers(t *testing.T) {
    sum := Add(-2, -3)
    if sum != -5 {
        t.Errorf("Add was incorrect, got: %d, want: %d.", sum, -5)
    }
}

// New test case for the Multiply function with zero
func TestMultiplyByZero(t *testing.T) {
    product := Multiply(0, 5)
    if product != 0 {
        t.Errorf("Multiply was incorrect, got: %d, want: %d.", product, 0)
    }
}

After adding more test cases, run the coverage commands again to see the improvements.

Profiling

Step 1: Write a Simple Program

Let's use a simple program that contains a loop for profiling. Create a file named fibonacci.go:

package fibonacci

// Fibonacci returns the n-th Fibonacci number.
func Fibonacci(n int) int {
    if n < 2 {
        return n
    }
    return Fibonacci(n-1) + Fibonacci(n-2)
}

Step 2: Profile a Function

In order to profile the Fibonacci function, we need to modify our main program to include profiling functionality. Let's create a file named main.go:

package main

import (
    "fmt"
    "log"
    "os"
    "runtime/pprof"
    fibonacci "path_to_your_fibonacci_package/fibonacci"
)

func main() {
    // CPU Profiling
    fcpu, err := os.Create("cpu.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer fcpu.Close()
    pp := pprof.StartCPUProfile(fcpu)
    defer pp.Stop()

    // Calculate Fibonacci number
    fmt.Println("Fibonacci of 40:", fibonacci.Fibonacci(40))

    // Memory Profiling
    fm, err := os.Create("mem.prof")
    if err != nil {
        log.Fatal(err)
    }
    defer fm.Close()
    pprof.WriteHeapProfile(fm)
}

Make sure to replace path_to_your_fibonacci_package with the actual path to your fibonacci package.

Step 3: Run the Program

Compile and run the program:

go run main.go

Step 4: Analyze Profiles

For CPU profiling, use the pprof tool as follows:

go tool pprof cpu.prof

In the pprof shell, you can type commands like:

• top: to see top CPU consuming functions
• web: to visualize the call graph

For memory profiling, use:

go tool pprof mem.prof

Similar commands can be used here:

• top: to see top memory allocation functions
• web: to visualize the memory allocation call graph

Final Thoughts