Golang: When Identical Strings are Not Equal
This will be a quick and dirty post, so please forgive any spelling/grammar mistakes.
I was writing a little CLI tool in Golang to track todo items. Just a dumb little app to help hone my skills a bit, but still something useful that serves a purpose to me. I don’t write a ton of code at work (mostly just scripting/pipelines when I do), so I’m constantly working on something like this in my spare time. Anyway, I was writing this app, got everything working like I wanted it to. I then wrote some of the tests and was iterating over them. I noticed the ListTasks test was failing:
func TestAddTask(t *testing.T) {
task := "test task number 1"
dir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
cmdPath := filepath.Join(dir, binaryName)
t.Run("AddNewTask", func(t *testing.T) {
cmd := exec.Command(cmdPath, "-add", task)
if err := cmd.Run(); err != nil {
t.Fatal(err)
}
})
// failing test
t.Run("ListTasks", func(t *testing.T) {
cmd := exec.Command(cmdPath, "-list")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err)
}
expected := fmt.Sprintf("[ ] 1: %s", task)
if strings.Compare(string(out), expected) != 0 {
t.Errorf("got %v, expected %v\n", out, []byte(expected))
}
})
}
Seems strange, considering the strings appear to be equivalent in the output:
ryan:todo/ |main U:4 ?:1 ✗|$ go test -v
Building tool...
using /tmp/.testtodo.json
running...
=== RUN TestAddTask
=== RUN TestAddTask/AddNewTask
=== RUN TestAddTask/ListTasks
main_test.go:82: got [ ] 1: test task number 1
, expected [ ] 1: test task number 1
--- FAIL: TestAddTask (0.00s)
--- PASS: TestAddTask/AddNewTask (0.00s)
--- FAIL: TestAddTask/ListTasks (0.00s)
FAIL
cleaning up...
exit status 1
FAIL github.com/rnemeth90/todo/cmd/todo 0.105s
What could be happening? After banging my head on the desk a few times, a revelation came to me…
In Go, strings are simply slices of bytes. I decided to print out each string as a byte array:
ryan:todo/ |main U:4 ?:1 ✗|$ go test -v
Building tool...
using /tmp/.testtodo.json
running...
=== RUN TestAddTask
=== RUN TestAddTask/AddNewTask
=== RUN TestAddTask/ListTasks
main_test.go:80: got [91 32 93 32 49 58 32 116 101 115 116 32 116 97 115 107 32 110 117 109 98 101 114 32 49 32 10 10], expected [91 32 93 32 49 58 32 116 101 115 116 32 116 97 115 107 32 110 117 109 98 101 114 32 49]
--- FAIL: TestAddTask (0.00s)
--- PASS: TestAddTask/AddNewTask (0.00s)
--- FAIL: TestAddTask/ListTasks (0.00s)
FAIL
cleaning up...
exit status 1
FAIL github.com/rnemeth90/todo/cmd/todo 0.144s
Let’s take a closer look at the byte arrays from the test output:
got [91 32 93 32 49 58 32 116 101 115 116 32 116 97 115 107 32 110 117 109 98 101 114 32 49 32 10 10]
expected [91 32 93 32 49 58 32 116 101 115 116 32 116 97 115 107 32 110 117 109 98 101 114 32 49]
We can see the byte array returned from cmd.CombinedOutput() has some additional bytes in it at the end (32,10,10). What exactly are 32, 10, and 10? To figure this out, I went over to the go playground: https://go.dev/play/.
Let’s see what happens when we create a byte array with a single number and print it out as a string to the console:
Interesting, we can see that m was output to the console. So what do our mysterious additional characters in our test result represent? Let’s see:
It’s hard to tell from the output, but if you look in the results pane, you’ll see a space and two new lines. So 32 represents a space, and 10 represents a new line!
You can play with this code yourself: https://go.dev/play/p/fGUIxJM6KnV
Ok, so let’s fix our failing test:
func TestAddTask(t *testing.T) {
task := "test task number 1"
dir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
cmdPath := filepath.Join(dir, binaryName)
t.Run("AddNewTask", func(t *testing.T) {
cmd := exec.Command(cmdPath, "-add", task)
if err := cmd.Run(); err != nil {
t.Fatal(err)
}
})
t.Run("ListTasks", func(t *testing.T) {
cmd := exec.Command(cmdPath, "-list")
out, err := cmd.CombinedOutput()
if err != nil {
t.Fatal(err)
}
// add this line
out = []byte(strings.TrimSuffix(string(out), " \n\n"))
expected := fmt.Sprintf("[ ] 1: %s", task)
if strings.Compare(string(out), expected) != 0 {
t.Errorf("got %v, expected %v\n", out, []byte(expected))
}
})
}
The strings package has a TrimSuffix function that is useful for trimming bits off the end of a string. In the code above, you can see that we added out = []byte(strings.TrimSuffix(string(out), " \n\n")), which will trim off the space (character 32) and the two new lines (character 10). Now when we run our integration test, it passes:
ryan:todo/ |main U:4 ?:1 ✗|$ go test -v
Building tool...
using /tmp/.testtodo.json
running...
=== RUN TestAddTask
=== RUN TestAddTask/AddNewTask
=== RUN TestAddTask/ListTasks
--- PASS: TestAddTask (0.00s)
--- PASS: TestAddTask/AddNewTask (0.00s)
--- PASS: TestAddTask/ListTasks (0.00s)
PASS
cleaning up...
ok github.com/rnemeth90/todo/cmd/todo 0.106s