newCert, newkey, err := pkiutil.NewCertAndKey(testCACert, testCAKey, testCertCfg)
	if err != nil {
		t.Fatalf("couldn't generate certificate: %v", err)
	}

	// Writes the new certificate
	err = pkiReadWriter.Write(newCert, newkey)
	if err != nil {
		t.Fatalf("couldn't write new certificate: %v", err)
	}

	// Reads back the new certificate
	readCert, err = pkiReadWriter.Read()
	if err != nil {

	fieldnum int                  // the last field number written.
	buf      [1 + uint64Size]byte // buffer used by the encoder; here to avoid allocation.
	next     *encoderState        // for free list
}

// encBuffer is an extremely simple, fast implementation of a write-only byte buffer.
// It never returns a non-nil error, but Write returns an error value so it matches io.Writer.
type encBuffer struct {
	data    []byte
	scratch [64]byte

		return
	}
	if (zb0001Mask & 0x1) == 0 { // if not omitted
		// write "V2Obj"
		err = en.Append(0xa5, 0x56, 0x32, 0x4f, 0x62, 0x6a)
		if err != nil {
			return
		}
		if z.ObjectV2 == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			// map header, size 1
			// write "DDir"
			err = en.Append(0x81, 0xa4, 0x44, 0x44, 0x69, 0x72)
			if err != nil {

        System.setProperty("org.gradle.appname", "some-gradle-launcher")
        StringWriter writer = new StringWriter()
        GradleLauncherMetaData metaData = new GradleLauncherMetaData()

        when:
        metaData.describeCommand(writer, "[options]", "<task-name>")

        then:
        writer.toString() == "some-gradle-launcher [options] <task-name>"
    }

     */
    T read(Decoder decoder) throws EOFException, Exception;

    /**
     * Writes the given object to the given stream. The implementation must not perform any buffering.
     */
    void write(Encoder encoder, T value) throws Exception;

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package runtime

// traceExpWriter is a wrapper around trace writer that produces traceEvExperimentalBatch
// batches. This means that the data written to the writer need not conform to the standard
// trace format.
type traceExpWriter struct {
	traceWriter
	exp traceExperiment
}

			}
		}
		c.Exited(err)
		if err != nil {
			c.Close()
			os.Exit(1)
		}
	}
}

type countWriter struct {
	n int64
	w io.Writer
}

func (w *countWriter) Write(b []byte) (int, error) {
	w.n += int64(len(b))
	return w.w.Write(b)

        public void writeAllOutput(long classId, TestOutputEvent.Destination destination, java.io.Writer writer) {
            doRead(classId, 0, true, destination, writer);
        }

        public void writeNonTestOutput(long classId, TestOutputEvent.Destination destination, java.io.Writer writer) {
            doRead(classId, 0, false, destination, writer);
        }

        cache.set "a"

        then:
        1 * serializer.write(_, "a")

        when: // same value is not written
        def r = cache.maybeUpdate { it }

        then:
        r == "a"
        1 * serializer.read(_)

        and:
        0 * serializer.write(_, _)

        when: // different value is written back
        r = cache.maybeUpdate { "b" }

        then:

	}

	if transcript != nil {
		transcript.Write(data)
	}

	return m, nil
}

var (
	errShutdown = errors.New("tls: protocol is shutdown")
)

// Write writes data to the connection.
//
// As Write calls [Conn.Handshake], in order to prevent indefinite blocking a deadline
// must be set for both [Conn.Read] and Write before Write is called when the handshake