}
	n, handled, e := f.writeTo(w)
	if handled {
		return n, f.wrapErr("read", e)
	}
	return genericWriteTo(f, w) // without wrapping
}

// noWriteTo can be embedded alongside another type to
// hide the WriteTo method of that other type.
type noWriteTo struct{}

// WriteTo hides another WriteTo method.
// It should never be called.
func (noWriteTo) WriteTo(io.Writer) (int64, error) {

            TestUtil.checksumService
        ).writeTo(writer, spec)
    }

    def "fails to write file for component with no variants"() {
        def writer = new StringWriter()
        def component = Stub(TestComponent)
        def publication = publication(component, id)

        when:
        writeTo(writer, publication, [publication])

        then:

        writer.print(type);
        if (description != null) {
            writer.print(" (");
            writer.print(description);
            writer.print(")");
        }
        writer.println(" is invalid due to incompatible types.");
        writer.print("This element was created by ");
        writer.print(creator);
        writer.print(" and can be ");
        writer.print(writable ? "mutated" : "read");

                    writeTo(data);
                    return data.toInputStream();
                }

                @Override
                public void writeTo(OutputStream output) throws IOException {
                    legacyWriter.writeTo(output);
                }

                @Override
                public long getSize() {

// Instance of a configured Envoy bootstrap writer.
type Instance interface {
	// WriteTo writes the content of the Envoy bootstrap to the given writer.
	WriteTo(templateFile string, w io.Writer) error

	// CreateFile generates an Envoy bootstrap file.
	CreateFile() (string, error)
}

// New creates a new Instance of an Envoy bootstrap writer.
func New(cfg Config) Instance {
	return &instance{
		Config: cfg,

            writer.print(" (");
            writer.print(referenceDescription);
            writer.print(")");
        }
        writer.println(" is ambiguous as multiple model elements are available for this type:");

        boolean first = true;
        for (Provider provider : providers) {
            if (!first) {
                writer.println();
            }
            writer.print(INDENT);
            writer.print("- ");

		MultiReader( // Tickle the buffer reusing codepath
			strings.NewReader(""),
			strings.NewReader("bar"),
		),
	)
	mrAsWriterTo, ok := mr.(WriterTo)
	if !ok {
		t.Fatalf("expected cast to WriterTo to succeed")
	}
	sink := &strings.Builder{}
	n, err := mrAsWriterTo.WriteTo(sink)
	if err != nil {
		t.Fatalf("expected no error; got %v", err)
	}
	if n != 7 {
		t.Errorf("expected read 7 bytes; got %d", n)
	}

		return nil
	}

	writeErr := reduceWriteQuorumErrs(ctx, p.errs, objectOpIgnoredErrs, p.writeQuorum)
	return fmt.Errorf("%w (offline-disks=%d/%d)", writeErr, countErrs(p.errs, errDiskNotFound), len(p.writers))
}

// Encode reads from the reader, erasure-encodes the data and writes to the writers.
func (e *Erasure) Encode(ctx context.Context, src io.Reader, writers []io.Writer, buf []byte, quorum int) (total int64, err error) {

Joe Tsai <******@****.***> 1503528984 -0700

type Buffers [][]byte

var (
	_ io.WriterTo = (*Buffers)(nil)
	_ io.Reader   = (*Buffers)(nil)
)

// WriteTo writes contents of the buffers to w.
//
// WriteTo implements [io.WriterTo] for [Buffers].
//
// WriteTo modifies the slice v as well as v[i] for 0 <= i < len(v),
// but does not modify v[i][j] for any i, j.
func (v *Buffers) WriteTo(w io.Writer) (n int64, err error) {