It looks like only two examples are failing:

• ExampleNew, because it tries to perform network operations that GopherJS doesn't support (i.e., it tries to create a new HTTP server with httptest.NewServer).
• ExampleStructOf is failing because reflect.StructOf is not supported (see Support reflect.StructOf function (new to Go 1.7). #499).

In the case of net/http/cookiejar, ExampleNew is the only example it has.

However, for reflect, there are other examples. Do you know if they work?

I think it'd be nice to simply disable the failing/unsupported examples, the way we already do it for tests (e.g., see 3303ee8), instead of outright disabling all examples for the packages that contain examples that don't work. That'd be cleaner, and hopefully some examples in reflect packages do pass (and might catch regressions in the future).

I believe that's the only failure in the reflect package. I was essentially being lazy about creating yet another special case to run the other examples, but I can do that.

Well, it would allow you to simplify circle.yml back to the original version. I think it's worth doing, if it's indeed possible. Thanks!

Ah yes, that is a much better approach. I'll make that change.

Why not check errors from io.Copy?

How about this:

func readFile(filename string) (string, error) {
	f, err := os.Open(filename)
	if err != nil {
		return "", err
	}
	defer f.Close()
	var buf bytes.Buffer
	_, err = io.Copy(&buf, f)
	if err != nil {
		return "", err
	}
	return buf.String(), nil
}

It would also be more efficient to do a stat on the file to get its size, then allocate a buffer of exactly that size. I'm guessing you chose not to do that because most test output is pretty small, so it's not worth it. Is that the reason?

What is the best way of allocating a bytes.Buffer of a specific size?

b := make([]byte,size)
buf := bytes.NewBuffer(b)

?

Depends on if you want a byte slice, then:

b := make([]byte, 0, capacity)
... populate/use b

Or if you want a bytes.Buffer, then:

buf := bytes.NewBuffer(make([]byte, 0, capacity))
... populate/use buf

See bytes.NewBuffer documentation:

NewBuffer creates and initializes a new Buffer using buf as its initial contents. It is intended to prepare a Buffer to read existing data. It can also be used to size the internal buffer for writing. To do that, buf should have the desired capacity but a length of zero.

Just trying to understand this better. Do you know why the original Go code did this here in a goroutine, instead of simply doing it at the end (original line 51, out := <-outC)?

Is it so that writes into the write-end of pipe don't block? I don't know how io.Pipe works in that sense. Do you need to read from the read-end, otherwise writing-end blocks?

Ok, reading its documentation confirms that's the case:

Pipe creates a synchronous in-memory pipe. It can be used to connect code expecting an io.Reader with code expecting an io.Writer.

Reads and Writes on the pipe are matched one to one except when multiple Reads are needed to consume a single Write. That is, each Write to the PipeWriter blocks until it has satisfied one or more Reads from the PipeReader that fully consume the written data. The data is copied directly from the Write to the corresponding Read (or Reads); there is no internal buffering.

This isn't the approach I meant. Is it possible to override and skip examples similar to how we skip failing/unsupported tests?

Look at 3303ee8 for example.

There's no t.Skip for examples, but just leaving the func body blank would probably work, right?

My goal is to simplify the command to run tests to just gopherjs test --short --minify ... instead of adding more special cases. That way, it's easier to run it locally, not just in CI.

I realized after I committed the change. Stand by for an update.

If there's any error during reading the example stdout file, _ = os.Remove(w.Name()) line will never run.

Would the following be better?

out, readFileError := ioutil.ReadFile(w.Name())
os.Remove(w.Name())
if readFileError != nil {
	fmt.Fprintf(os.Stderr, "testing: reading stdout file: %v\n", readFileError)
	os.Exit(1)
}

It's very helpful (for later) to put a comment inside that explains why a test/example is disabled:

func ExampleNew() {
    // Example relies on httptest.NewServer, which GopherJS does not implement.
}

Same here.

func ExampleStructOf() {
    // Blocked on https://github.com/gopherjs/gopherjs/issues/499.
}

I think this needs to be package cookiejar_test. The example is in an external test package.

See https://github.com/golang/go/blob/go1.8/src/net/http/cookiejar/example_test.go#L5.

Same here, package reflect_test.

See https://github.com/golang/go/blob/go1.8/src/reflect/example_test.go#L5.

gofmt?

This change is so clean and beautiful now. 👍 😻

Minor, we've changed the code to use file rather than pipe, but the comment still says pipe.

I can fix it.