}

    @Override
    public void close() throws Exception {
        ArrayList<Exception> exceptions = new ArrayList<>();
        for (CommandRegistry commandRegistry : commandRegistries) {
            if (commandRegistry instanceof AutoCloseable closeable) {
                try {
                    closeable.close();
                } catch (Exception e) {
                    exceptions.add(e);

        ) {
          webSocket.send(text)
        }

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) {

        rbc = Channels.newChannel(website.openStream());
        FileOutputStream fos = new FileOutputStream(destination);
        fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
        fos.close();
        rbc.close();
    }

     */
    void write(File output, Map<String, Object> options, Model model) throws IOException;

    /**
     * Writes the supplied model to the specified character writer. The writer will be automatically closed before the
     * method returns.
     *
     * @param output The writer to serialize the model to, must not be {@code null}.

      MockResponse
        .Builder()
        .body("Hello!")
        .setHeader("Content-Type", PLAIN)
        .build(),
    )
    val response = client.newCall(request().build()).execute()
    response.body.close()
    applicationLogs
      .assertLogEqual("--> GET $url")
      .assertLogMatch(Regex("""<-- 200 OK $url \(\d+ms, 6-byte body\)"""))
      .assertNoMoreLogs()
    networkLogs

    if (hasErrors) {
      return
    }
    try {
      super.flush()
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

  override fun close() {
    try {
      super.close()
    } catch (e: IOException) {
      hasErrors = true
      onException(e)
    }
  }

	if osync {
		flags |= os.O_SYNC
	}
	appendFile, err := os.OpenFile(dst, flags, 0o666)
	if err != nil {
		return err
	}
	defer appendFile.Close()

	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	defer srcFile.Close()
	_, err = io.Copy(appendFile, srcFile)
	return err

func (s *Stack) Push(tr TokenReader) {
	s.tr = append(s.tr, tr)
}

func (s *Stack) Next() ScanToken {
	tos := s.tr[len(s.tr)-1]
	tok := tos.Next()
	for tok == scanner.EOF && len(s.tr) > 1 {
		tos.Close()
		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

func (s *Stack) Text() string {
	return s.tr[len(s.tr)-1].Text()

  }

  private final class Out extends TestOutputStream {

    Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

                try {
                  serverSocket.close();
                  finalizeReferentRan.set(true);
                } catch (IOException e) {
                  throw new UncheckedIOException(e);
                }
              }
            }
          };
      references.add(reference);
      return myServer;
    }

    @Override
    public void close() throws IOException {
      serverSocket.close();