System.out.println("< html allowed, cdata closing token ]]> encoded!");
                    System.out.print("no EOL, ");
                    System.out.println("non-asci char: ż");
                    System.out.println("xml entity: &amp;");
                    System.err.println("< html allowed, cdata closing token ]]> encoded!");
                }

	p := &GCEPlugin{
		aud:              audience,
		jwtPath:          jwtPath,
		identityProvider: identityProvider,
		closing:          make(chan bool),
	}
	if rotateToken {
		go p.startTokenRotationJob()
	}
	return p
}

func (p *GCEPlugin) Stop() {
	close(p.closing)
}

func (p *GCEPlugin) startTokenRotationJob() {
	// Wake up once in a while and refresh GCE VM credential.

	ExpectArrayDelimiterOrEndParserState                    // expect array delimiter (,) or end of array (])
	ExpectArgsEndParserState                                // expect closing ) in %VAR(...)%
	ExpectVariableEndParserState                            // expect closing % in %VAR(...)%
)

// validateHeaderValue is golang port version of
// https://github.com/envoyproxy/envoy/blob/master/source/common/router/header_parser.cc#L73

    }

    def "rethrows unchecked exception when closing resource"() {
        def resource = Mock(Closeable)

        when:
        uncheckedClose(resource)

        then:
        1 * resource.close() >> { throw new IOException() }
        thrown(UncheckedIOException)
    }

    def "does not rethrow exception when closing resource"() {
        def resource = Mock(Closeable)

        when:

func (wq *WorkQueue) Delete(target Resource) {
	wq.lock.Lock()
	defer wq.lock.Unlock()
	delete(wq.cache, convert(target))
}

type WorkerPool struct {
	q WorkQueue
	// indicates the queue is closing
	closing bool
	// the function which will be run for each task in queue
	write func(*config.Config, any)
	// the function to retrieve the initial status
	get func(Resource) *config.Config
	// current worker routine count

    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosing(webSocket, code, reason)
    } else {
      events.add(Closing(code, reason))
    }
  }

  override fun onClosed(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosed $code", Platform.INFO, null)

// errorcheck

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test error recovery after missing closing parentheses in lists.

package p

func f() {
	x := f(g() // ERROR "unexpected newline"
	y := 1
}

func g() {
}

func h() {
	x := f(g() // ERROR "unexpected newline"
}

func i() {

}

// An svnState describes the state of a port serving the 'svn://' protocol.
type svnState struct {
	listener  net.Listener
	listenErr error
	conns     map[net.Conn]struct{}
	closing   bool
	done      chan struct{}
}

func (h *svnHandler) Available() bool {
	h.pathOnce.Do(func() {
		h.svnservePath, h.svnserveErr = exec.LookPath("svnserve")
	})
	return h.svnserveErr == nil
}

    public void close() {
        LOGGER.debug("Closing {} build cache", role.getDisplayName());
        if (disabled) {
            LOGGER.warn("The {} build cache was disabled during the build due to errors.", role.getDisplayName());
        }
        try {
            service.close();
        } catch (Exception e) {
            if (logStackTraces) {
                LOGGER.warn("Error closing {} build cache: ", role.getDisplayName(), e);

     */
    InputStream open();

    /**
     * Copies the content of this file to an output stream. Generally, calling this method is more performant than
     * calling {@code new FileInputStream(getFile())}.
     *
     * @param output The output stream to write to. The caller is responsible for closing this stream.
     */
    void copyTo(OutputStream output);