}
			case testWriteTo:
				f := &testFile{ops: tf.ops}
				got, err := fr.WriteTo(f)
				if _, ok := err.(testError); ok {
					t.Errorf("test %d.%d, WriteTo(): %v", i, j, err)
				} else if got != tf.wantCnt || err != tf.wantErr {
					t.Errorf("test %d.%d, WriteTo() = (%d, %v), want (%d, %v)", i, j, got, err, tf.wantCnt, tf.wantErr)

		t.Errorf("Write error: got %T, want testError1", err)
	}

	rb.CloseWithError(testError2{})
	if _, err := rb.Write(nil); err != (testError1{}) {
		t.Errorf("Write error: got %T, want testError1", err)
	}

	rb.Reset()
	rb.CloseWithError(testError1{})
	if _, err := rb.Read(nil); err != (testError1{}) {
		t.Errorf("Read error: got %T, want testError1", err)
	}

		want   bool
	}{
		{
			name:   "url.Error",
			err:    &url.Error{Op: "PUT", URL: "http://localhost/1234", Err: restError("remote server offline")},
			target: &url.Error{},
			want:   true,
		},
		{
			name: "net.Error",
			err:  &url.Error{Op: "PUT", URL: "http://localhost/1234", Err: restError("remote server offline")},
			want: true,
		},
		{
			name: "net.Error-unmatched",
			err:  errors.New("something"),

		if goarm == 6 {
			testEndToEnd(t, "arm", "armv6")
		}
	}
}

func TestGoBuildErrors(t *testing.T) {
	testErrors(t, "amd64", "buildtagerror")
}

func TestGenericErrors(t *testing.T) {
	testErrors(t, "amd64", "duperror")
}

func TestARMErrors(t *testing.T) {
	testErrors(t, "arm", "armerror")
}

func TestARM64EndToEnd(t *testing.T) {
	testEndToEnd(t, "arm64", "arm64")
}

        def testStartEvent2 = startEvent("testId2")
        def testError2 = Mock(Throwable)

        when:
        processor.started(rootDescriptor, rootTestStartEvent)
        processor.started(testDescriptor1, testStartEvent1)
        processor.started(testDescriptor2, testStartEvent2)
        processor.failure("testId2", testError2)
        processor.completed("rootId", rootCompleteEvent)

        then:

	url        *url.URL
	auth       func() string

	sync.RWMutex // mutex for lastErr
	lastErr      error
	lastErrTime  time.Time
}

type restError string

func (e restError) Error() string {
	return string(e)
}

func (e restError) Timeout() bool {
	return true
}

// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
// return true if the string includes a port.

    assertTrue(c2.isClosed());

    assertSuppressed(
        new Suppression(c2, tryException, c2Exception),
        new Suppression(c1, tryException, c1Exception));
  }

  public void testErrors() throws IOException {
    Closer closer = new Closer(suppressor);

    Error c1Exception = new Error();
    Error c2Exception = new Error();
    Error c3Exception = new Error();

    assertTrue(c2.isClosed());

    assertSuppressed(
        new Suppression(c2, tryException, c2Exception),
        new Suppression(c1, tryException, c1Exception));
  }

  public void testErrors() throws IOException {
    Closer closer = new Closer(suppressor);

    Error c1Exception = new Error();
    Error c2Exception = new Error();
    Error c3Exception = new Error();

pkg syscall (linux-386), type Timex struct, Calcnt int32
pkg syscall (linux-386), type Timex struct, Constant int32
pkg syscall (linux-386), type Timex struct, Errcnt int32
pkg syscall (linux-386), type Timex struct, Esterror int32
pkg syscall (linux-386), type Timex struct, Freq int32
pkg syscall (linux-386), type Timex struct, Jitcnt int32
pkg syscall (linux-386), type Timex struct, Jitter int32

pkg syscall (linux-arm-cgo), type Timex struct, Constant int32
pkg syscall (linux-arm-cgo), type Timex struct, Errcnt int32
pkg syscall (linux-arm-cgo), type Timex struct, Esterror int32
pkg syscall (linux-arm-cgo), type Timex struct, Freq int32
pkg syscall (linux-arm-cgo), type Timex struct, Jitcnt int32
pkg syscall (linux-arm-cgo), type Timex struct, Jitter int32