Test-driven basics in Go - Step-by-Step Execution

Concept Flow - Test-driven basics

Write a failing test

↓

Run test: it fails

↓

Write code to pass test

↓

Run test: it passes

↓

Refactor code if needed

↓

Repeat for next feature

This flow shows how you first write a test that fails, then write code to pass it, run tests to confirm, and finally improve code.

Execution Sample

Go

package main
import "testing"

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

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

This Go code defines a simple Add function and a test that checks if Add(2,3) returns 5.

Execution Table

Step	Action	Test Result	Code State
1	Write TestAdd checking Add(2,3)==5	No test run yet	Add function not implemented or empty
2	Run tests	Fail: Add returns 0 or no code	Add function empty or wrong
3	Write Add function returning a+b	Code updated to correct logic	Add returns sum of inputs
4	Run tests again	Pass: Add(2,3) == 5	Code correct, test passes
5	Refactor code if needed	Tests still pass	Code clean and working
6	End	All tests pass, development done	Ready for next feature

💡 All tests pass, so development cycle completes successfully

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
Add(2,3) result	undefined	5	5	5
Test status	not run	not run	pass	pass

Key Moments - 3 Insights

Why does the test fail at first before writing the Add function?

Because the Add function is not implemented or returns wrong value, so the test checking Add(2,3)==5 fails as shown in execution_table step 2.

Why do we run tests again after writing the Add function?

To confirm the new code works and the test passes, as shown in execution_table step 4 where the test passes.

What is the purpose of refactoring after tests pass?

To improve code quality without changing behavior, ensuring tests still pass as in execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution_table, what is the test result at step 2?

A No test run yet

B Pass: Add(2,3) == 5

C Fail: Add returns 0 or no code

D Tests skipped

💡 Hint

Check the 'Test Result' column at step 2 in execution_table

At which step does the Add function get implemented correctly?

A Step 3

B Step 1

C Step 4

D Step 5

💡 Hint

Look at 'Code State' column to see when Add returns sum of inputs

If the Add function returned a fixed number 10 instead of a+b, what would happen at step 4?

A Test would pass

B Test would fail

C Test would not run

D Test would be skipped

💡 Hint

Refer to variable_tracker where Add(2,3) result must be 5 to pass test

Concept Snapshot

Test-driven basics in Go:
1. Write a test that fails.
2. Run tests to confirm failure.
3. Write code to pass the test.
4. Run tests to confirm pass.
5. Refactor code while tests pass.
Repeat for new features.

Full Transcript

Test-driven basics means first writing a test that checks what your code should do. Initially, the test fails because the code is missing or wrong. Then you write the code to make the test pass. You run the tests again to confirm success. After that, you can clean up your code without breaking the test. This cycle repeats for each new feature or fix. The example shows a simple Add function and its test in Go. The test first fails, then passes after writing Add, demonstrating the test-driven process.

Practice

1. What is the main purpose of writing tests in Go using the testing package?

easy

A. To make the program run faster

B. To add comments to the code

C. To check if the code works correctly by running test functions

D. To create user interfaces

Solution

1. Step 1: Understand the role of tests in Go

   Tests are written to verify that the code behaves as expected.

2. Step 2: Identify what the testing package does

   The testing package provides tools to write and run tests that check code correctness.

3. Final Answer:

   To check if the code works correctly by running test functions -> Option C

4. Quick Check:

   Tests check code correctness = B [OK]

Hint: Tests verify code correctness before running fully [OK]

Common Mistakes:

• Thinking tests improve speed
• Confusing tests with comments
• Assuming tests create UI

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

easy

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

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

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

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

Solution

1. Step 1: Recall Go test function naming rules

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

2. Step 2: Match the correct function signature

   Only func TestMyFunc(t *testing.T) {} follows this rule exactly.

3. Final Answer:

   func TestMyFunc(t *testing.T) {} -> Option D

4. Quick Check:

   Test functions start with "Test" = C [OK]

Hint: Test functions must start with uppercase 'Test' [OK]

Common Mistakes:

• Starting function name with lowercase 'test'
• Adding extra words before 'Test'
• Using wrong parameter types

3. What will be the output when running go test on this test file?

package main

import "testing"

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

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

medium

A. No output

B. PASS

C. Compilation error

D. FAIL with error 'Expected 5'

Solution

1. Step 1: Analyze the Add function and test

   The Add function returns the sum of 2 and 3, which is 5.

2. Step 2: Check the test condition

   The test expects Add(2, 3) to be 5, which is true, so no error is called.

3. Final Answer:

   PASS -> Option B

4. Quick Check:

   Correct sum means test passes = D [OK]

Hint: If test condition matches, output is PASS [OK]

Common Mistakes:

• Assuming test fails when condition is true
• Thinking test prints 'Expected 5' on success
• Confusing test failure with compile error

4. Identify the error in this test code snippet:

package main

import "testing"

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

medium

A. Multiply function is not defined

B. Missing import for Multiply function

C. Test function name should be lowercase

D. t.Error should be t.Fail

Solution

1. Step 1: Check if Multiply function is defined

   The code snippet does not show any definition or import of Multiply function.

2. Step 2: Understand Go requires functions to be defined or imported

   Without definition or import, the code will not compile.

3. Final Answer:

   Multiply function is not defined -> Option A

4. Quick Check:

   Undefined function causes compile error = A [OK]

Hint: Undefined functions cause compile errors [OK]

Common Mistakes:

• Thinking test function names can be lowercase
• Confusing t.Error with t.Fail
• Assuming missing import causes runtime error

5. You want to write a test that fails if a function returns an empty string. Which test code snippet correctly implements this check?

hard

A. func TestEmpty(t *testing.T) {
if MyFunc() == "" {
t.Error("Result should not be empty")
}
}

B. func TestEmpty(t *testing.T) {
if MyFunc() != "" {
t.Error("Result should be empty")
}
}

C. func TestEmpty(t *testing.T) {
if MyFunc() == nil {
t.Error("Result should not be nil")
}
}

D. func TestEmpty(t *testing.T) {
if MyFunc() == 0 {
t.Error("Result should not be zero")
}
}

Solution

1. Step 1: Understand the test goal

   The test should fail if the function returns an empty string "".

2. Step 2: Check each option's condition

   func TestEmpty(t *testing.T) { if MyFunc() == "" { t.Error("Result should not be empty") } } fails when MyFunc() returns "", which matches the goal.

3. Final Answer:

   func TestEmpty(t *testing.T) { if MyFunc() == "" { t.Error("Result should not be empty") } } -> Option A

4. Quick Check:

   Fail on empty string = A [OK]

Hint: Fail test if function returns empty string "" [OK]

Common Mistakes:

• Checking for nil instead of empty string
• Checking for zero instead of string
• Reversing the condition logic