writer.write(" ");
            writer.write(input.getType() == null ? "<untyped>" : input.getType());
            if (input.getDescription() != null) {
                writer.write(" ");
                writer.write("(");
                writer.write(input.getDescription());
                writer.write(")");
            }
            if (!input.isBound()) {
                writer.write(" ");
                writer.write("[*]");

}

func ctxDriverBegin(ctx context.Context, opts *TxOptions, ci driver.Conn) (driver.Tx, error) {
	if ciCtx, is := ci.(driver.ConnBeginTx); is {
		dopts := driver.TxOptions{}
		if opts != nil {
			dopts.Isolation = driver.IsolationLevel(opts.Isolation)
			dopts.ReadOnly = opts.ReadOnly
		}
		return ciCtx.BeginTx(ctx, dopts)
	}

	if opts != nil {
		// Check the transaction level. If the transaction level is non-default

                        writer.print("\"");
                    }
                    writer.println();
                    writer.println("        ),");
                }
                writer.print("    ]");
                if (srcPackage.getSwiftLanguageVersion() != null) {
                    writer.println(",");

        when:
        def writer = output.writer()
        writer.onOutput(1, output(StdOut, "[out-1]"))
        writer.onOutput(1, 1, output(StdOut, "[out-2]"))
        writer.onOutput(1, output(StdErr, "[out-3]"))
        writer.onOutput(1, output(StdErr, "[out-4]"))
        writer.onOutput(1, output(StdOut, "[out-5]"))
        writer.onOutput(1, 2, output(StdOut, "[out-6]"))
        writer.onOutput(2, output(StdOut, "[out-6]"))

			continue
		}
		s := info.StreamSerializer
		framer := s.Framer
		embedded := info.Serializer
		if embedded == nil {
			t.Errorf("no embedded serializer for %s", info.MediaType)
			continue
		}
		innerDecode := legacyscheme.Codecs.DecoderToVersion(embedded, api.SchemeGroupVersion)

		// write a single object through the framer and back out
		obj := &bytes.Buffer{}

	// Setup a new watchserver
	watchServer := &handlers.WatchServer{
		Scope:    &handlers.RequestScope{},
		Watching: watcher,

		MediaType:       "testcase/json",
		Framer:          serializer.Framer,
		Encoder:         newCodec,
		EmbeddedEncoder: newCodec,

		TimeoutFactory: &fakeTimeoutFactory{timeoutCh, done},
	}

	s := httptest.NewServer(serveWatch(watcher, watchServer, nil))

        when:
        writer.startElement("root")
        writer.startElement("stuff")

        writer.startCDATA()
        writer.characters('x hey x'.toCharArray(), 2, 4)
        writer.characters('joe'.toCharArray())
        writer.characters("!")
        writer.endCDATA()

        writer.endElement()

        writer.startCDATA()
        writer.characters('encodes: ]]> ')

        public XmlWriterRequestBuilder<T> writer(Writer writer) {
            this.writer = writer;
            return this;
        }

        public XmlWriterRequestBuilder<T> content(T content) {
            this.content = content;
            return this;
        }

        public XmlWriterRequest<T> build() {
            return new DefaultXmlWriterRequest<>(path, outputStream, writer, content);
        }

    StringBuilder builder = new StringBuilder();
    Writer writer = new AppendableWriter(builder);

    writer.write("Hello".toCharArray());
    writer.write(',');
    writer.write(0xBEEF0020); // only lower 16 bits are important
    writer.write("Wo");
    writer.write("Whirled".toCharArray(), 3, 2);
    writer.write("Mad! Mad, I say", 2, 2);

    assertEquals("Hello, World!", builder.toString());
  }

        public String toString() {
            StringWriter writer = new StringWriter();
            writeTo(writer);
            return writer.toString();
        }

        public void writeTo(Writer writer) {
            doWriteTo(writer, null);
        }

        public void writeTo(Writer writer, String encoding) {
            doWriteTo(writer, encoding);
        }

        public void writeTo(File file) {