Let's look at: Trace, Profiling, Integration Testing, Code Coverage, Mocking, Deadlock Detection in Go vs Java | Testing, Debugging and Profiling

Series: Go for Java Developers — analysis of trace, profiling and testing

In this article we will analyze tools and practices for testing, debugging and profiling in Go. For a Java developer this will make it easy to navigate in Go, and for a Go developer — to compare approaches with Java.

---

Trace — program execution tracking

Go has a built-in package runtime/trace for detailed program analysis. Allows tracking goroutine, syscalls and execution time.

Trace example

// Go
import (
    "os"
    "runtime/trace"
    "time"
)

func main() {
    f, _ := os.Create("trace.out")
    defer f.Close()
    trace.Start(f)
    defer trace.Stop()

    time.Sleep(time.Second) // example work
}

Java equivalent: via Flight Recorder or JVisualVM profiler

// Java (example of recording events via Flight Recorder API)
import jdk.jfr.Recording;

public class Main {
    public static void main(String[] args) throws Exception {
        try (Recording recording = new Recording()) {
            recording.start();
            Thread.sleep(1000); // example work
            recording.stop();
            recording.dump(new java.io.File("trace.jfr").toPath());
        }
    }
}

Trace is useful for deep performance analysis and identifying bottlenecks, especially with concurrency.

---

CPU and memory profiling

Go provides the pprof package for CPU and memory profiling. This helps optimize resource usage.

CPU profile example

// Go
import (
    "os"
    "runtime/pprof"
)

func main() {
    f, _ := os.Create("cpu.prof")
    defer f.Close()
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()

    // load
    for i := 0; i < 1000000; i++ {}
}

Java equivalent: JVisualVM profiler or Java Flight Recorder

// Java
// CPU and heap profiling via JVisualVM / Flight Recorder
// Example of profiling manually in Java is not needed, GUI is used

Tip: profile CPU and memory regularly, especially under high loads and multithreading.

---

Integration Testing — integration tests

Go uses the testing package for unit and integration tests. Java uses JUnit/TestNG. In Go, tests are written simply and composed via *_test.go files.

Integration test example

// Go
import "testing"

func TestIntegration(t *testing.T) {
    result := 1 + 2
    if result != 3 {
        t.Error("Expected 3")
    }
}

Java equivalent:

// Java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class MainTest {
    @Test
    void testIntegration() {
        assertEquals(3, 1 + 2);
    }
}

---

Code Coverage — test coverage

Go supports code coverage analysis via go test -cover. Java — via JaCoCo or built-in IDE tools.

Command example

// Go
go test -cover ./...

Tip: 80%+ coverage is important for stability and confidence in code changes.

---

Mocking interfaces — dependency substitution

Go allows mocking interfaces manually or via third-party libraries (gomock). Java uses Mockito or PowerMock.

Go example

// Go
type DB interface {
    Get(id int) string
}

type MockDB struct{}

func (m MockDB) Get(id int) string {
    return "mocked"
}

Java equivalent:

// Java
import static org.mockito.Mockito.*;

interface DB {
    String get(int id);
}

public class Test {
    public void test() {
        DB mockDb = mock(DB.class);
        when(mockDb.get(1)).thenReturn("mocked");
    }
}

---

Deadlock detection — detecting deadlocks

Go race detector (go run -race) helps identify races and deadlocks. Java — thread dump, VisualVM or built-in IDE tools.

// Go
go run -race main.go

Tip: races and deadlocks are major multithreading issues. Use built-in tools for quick detection.

---

Comparison table Go ↔ Java

---

Practical conclusion

• Go has built-in tools for testing, profiling and debugging — easier to integrate into pipeline.
• Java offers powerful third-party tools and IDE, but requires more setup.
• Race detector and pprof — key tools for safe concurrency work.
• Mocking and coverage are convenient for maintainable and reliable code.
• Comparing approaches Go ↔ Java allows quick adaptation between languages and using best practices.