}

    @Override
    public void setContentCharset(String contentCharset) {
        this.contentCharset = contentCharset;
    }

    @Override
    public Manifest writeTo(OutputStream outputStream) {
        DefaultManifest.writeTo(this, outputStream, contentCharset);
        return this;
    }

    @Override
    public Attributes getAttributes() {
        return delegate.getAttributes();
    }

// do so because of a mistake in its method signature.
// For example, the result of this WriteTo method should be (int64, error),
// not error, to satisfy io.WriterTo:
//
//	type myWriterTo struct{...}
//	func (myWriterTo) WriteTo(w io.Writer) error { ... }
//
// This check ensures that each method whose name matches one of several

    @Rule TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())

    def "writes default descriptor"() {
        def file = tmpDir.file("out.xml")

        when:
        descriptor.writeTo(file)

        then:
        def root = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new ByteArrayInputStream(file.bytes)).documentElement
        root.nodeName == 'application'

              }
            }
        """
    }

    def "singleModule with same source and target"() {
        def source = Jvm.current().javaVersion
        def target = Jvm.current().javaVersion
        writePom(source, target)

        def dsl = dslFixtureFor(scriptDsl)

        when:
        run 'init', '--dsl', scriptDsl.id as String

        then:
        dsl.assertGradleFilesGenerated()

    val out = Buffer()
    body.writeTo(out)
    assertThat(out.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun encodedPair() {
    val body =
      FormBody.Builder()
        .add("sim", "ple")
        .build()
    val expected = "sim=ple"
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)

            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:

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

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

                @Override
                public long getSize() {

	return
}

// WriteToIP acts like [IPConn.WriteTo] but takes an [IPAddr].
func (c *IPConn) WriteToIP(b []byte, addr *IPAddr) (int, error) {
	if !c.ok() {
		return 0, syscall.EINVAL
	}
	n, err := c.writeTo(b, addr)
	if err != nil {
		err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err}
	}
	return n, err
}

// WriteTo implements the [PacketConn] WriteTo method.

        return read_op.emitOpError(kInvalidResourceMsg);
      }

      read_op.erase();
    } else if (auto write_op = llvm::dyn_cast<TF::AssignVariableOp>(&op)) {
      if (auto func_arg =
              mlir::dyn_cast<BlockArgument>(write_op.getResource())) {
        if (func_arg.getOwner() != &block)
          return write_op.emitOpError(kResourceFunctionMsg);

        ResourceInfo& resource_info = resources[func_arg.getArgNumber()];

            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void writeTo(int requestId, HttpExchange exchange) throws IOException {
        handler.writeTo(requestId, exchange);
    }