Writing basic test functions in Go - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a basic test function in Go.

Go

func TestAddition(t *[1]) {
    // test code here
}

Drag options to blanks, or click blank then click option'

Atesting.T

Btesting

CTest

DTestT

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong parameter type like 'Test' or 'testing' instead of '*testing.T'.

Forgetting the pointer '*' before 'testing.T'.

The parameter for a test function in Go must be *testing.T to access test methods.

2fill in blank

medium

Complete the code to fail the test if the sum is incorrect.

Go

func TestSum(t *testing.T) {
    result := 2 + 2
    if result != 4 {
        t.[1]("Sum is incorrect")
    }
}

Drag options to blanks, or click blank then click option'

AFailNow

BErrorf

CError

DFail

Attempts:

3 left

💡 Hint

Common Mistakes

Using Fail or FailNow without a message.

Using Error which does not accept formatting.

t.Errorf reports an error but continues the test. It's commonly used to show failure messages.

3fill in blank

hard

Fix the error in the test function declaration.

Go

func [1](t *testing.T) {
    product := 3 * 3
    if product != 9 {
        t.Errorf("Product is wrong")
    }
}

Drag options to blanks, or click blank then click option'

ATest_Multiply

BtestMultiply

CTestmultiply

DTestMultiply

Attempts:

3 left

💡 Hint

Common Mistakes

Starting the function name with lowercase 'test'.

Using underscores or incorrect capitalization.

Test functions must start with 'Test' and be exported (capitalized) to run automatically.

4fill in blank

hard

Fill both blanks to check if the function returns the expected value and fail the test if not.

Go

func TestSubtract(t *testing.T) {
    result := subtract(5, 3)
    if result [1] 2 {
        t.[2]("Expected 2 but got different value")
    }
}

Drag options to blanks, or click blank then click option'

A!=

B==

CErrorf

DFailNow

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' instead of '!=' in the condition.

Using 'FailNow' which stops the test immediately without message.

We check if the result is not equal to 2 using '!=' and report an error with t.Errorf.

5fill in blank

hard

Fill all three blanks to write a test that checks if the function returns true and fails the test if false.

Go

func TestIsEven(t *testing.T) {
    if ![1](4) {
        t.[2]("4 should be even")
        t.[3]()
    }
}

Drag options to blanks, or click blank then click option'

AisEven

BErrorf

CFailNow

DIsEven

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'IsEven' instead of 'isEven' if the function is lowercase.

Not calling t.FailNow() after reporting the error.

The function isEven is called to check 4. If false, t.Errorf reports the error and t.FailNow stops the test immediately.

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