I agree we need better documentation.

I want to support the current behavior, in that it makes it easy to casually add t.Log calls to your tests. They won't be printed if the test passes, but they will be if the test fails. So it makes it simpler to, as you, don't print stuff on success.

@ianlancetaylor no, t.Log calls are hidden unless -v is used, regardless of the package selector argument.

$ cat x_test.go
package main

import (
        "testing"
)

func TestFoo(t *testing.T) {
        t.Log("t.Log")
}
$ go1.9rc1 test
PASS
ok      _/home/caleb/test/p     0.002s
$ go1.9rc1 test .
ok      _/home/caleb/test/p     0.001s
$ go1.9rc1 test -v
=== RUN   TestFoo
--- PASS: TestFoo (0.00s)
        x_test.go:8: t.Log
PASS
ok      _/home/caleb/test/p     0.001s
$ go1.9rc1 test -v .
=== RUN   TestFoo
--- PASS: TestFoo (0.00s)
        x_test.go:8: t.Log
PASS
ok      _/home/caleb/test/p     0.002s

@ianlancetaylor I guess my response doesn't correspond to

They won't be printed if the test passes, but they will be if the test fails.

In my original post, what I intended to suggest is that it would be less confusing if go test <someargument> didn't hide output for passing tests (so it would behave the same way as go test). This change wouldn't affect what t.Log does, since that only prints with -v or on failure.

Sorry, I was supporting hiding the output of passing tests. I agree that it should be consistent.

@ianlancetaylor to be precise, are you suggesting that fmt.Println("hello") in a passing test should be hidden when you run go test?

Yes. (I can see a counter-argument, but that is my vote.)

New output for go help test, added since this bug was filed:

r$ go help test
...
Go test runs in two different modes: local directory mode when invoked with
no package arguments (for example, 'go test'), and package list mode when
invoked with package arguments (for example 'go test math', 'go test ./...',
and even 'go test .').

In local directory mode, go test compiles and tests the package sources
found in the current directory and then runs the resulting test binary.
In this mode, caching (discussed below) is disabled. After the package test
finishes, go test prints a summary line showing the test status ('ok' or 'FAIL'),
package name, and elapsed time.

In package list mode, go test compiles and tests each of the packages
listed on the command line. If a package test passes, go test prints only
the final 'ok' summary line. If a package test fails, go test prints the
full test output. If invoked with the -bench or -v flag, go test prints
the full output even for passing package tests, in order to display the
requested benchmark results or verbose logging.

I think this is now documented.

I stumbled upon this issue while using flags passed to the go test command to control behaviour during tests (setup). I seem to be experiencing a difference in output:

When running

go test ./...

I get a list of all packages, with OK, ?, or fail indication, and no other output, neither from log calls, nor from t.Log calls.

But when running

go test -compile ./...

I get output from all log calls (not from t.Log though - I guess you need -v for that).

I'm using the flag for flow control, in particular to control whether something gets comtpiled, or not - i don't really want to affect the verbosity of the output, yet I get flooded with output...

A minimal working example to reproduce the described behavior consists of the following to files, in an otherwise empty directory:

main.go:

package main

import (
  "log"
)

func main() {
}

func hello() {
  log.Println("hi")
}

test_main.go:

package main

import (
  "flag"
  "testing"
)

var (
  polite = flag.Bool("polite", false, "")
)

func TestFoo(t *testing.T) {
  hello()
}

results in outputs:

$ go test ./...
ok      _/test_playground/go_test     0.004s

and

$ go test -polite ./...
2018/01/28 12:38:23 hi
PASS
ok      _/Users/valkra/code/test_playground/go_test     0.005s

Is this expected behavior? Personally, I think it should not be ; )

It might be a good idea to add something about this in the docs either way.

@valentin-krasontovitsch This issue is closed, and, we believe, fixed. The Go project does not use the issue tracker for discussion; please ask your question on a forum: https://golang.org/wiki/Questions . Thanks.

Well, in my humble opinion the issue persists: the behavior I'm describing is (as far as I can see) undocumented. That I formulate this as a question and not a claim is simply due to the fact that I don't want to claim knowledge of all of the documentation, and cannot exclude to have overlooked something ...

Please advise -

1. do I have to reformulate and make it clearer that I would like to report an issue / bug?
2. do I have to open a new issue?

Let me try to make a clear statement, as my comment indeed seems to be missing this:

The (difference in) logging behavior of running go test with a list of packages while using custom flags (as opposed to not using custom flags) is undocumented.

Of course, if you have a link at hand pointing me to the right spot of the documentation, I would really appreciate it...

I can only repeat what I said above: this issue is closed and, we believe, fixed. This is not the place for further discussion. Please open a new issue or discuss this on a forum. Thanks.

I'm not even sure what you expect from go test -compile. There is no such option.