}
            }
        }

        then:
        def e = thrown(IllegalStateException)
        e.message.contains("closed")
    }

	return newUnixConn(fd), nil
}

func (ln *UnixListener) close() error {
	// The operating system doesn't clean up
	// the file that announcing created, so
	// we have to clean it up ourselves.
	// There's a race here--we can't know for
	// sure whether someone else has come along
	// and replaced our socket name already--
	// but this sequence (remove then close)
	// is at least compatible with the auto-remove

        noExceptionThrown()
    }

    @Issue("https://github.com/gradle/gradle/issues/24887")
    @Issue("https://github.com/gradle/gradle/issues/27099")
    def "build events listener service handles all events before it is closed"() {
        buildFile """
            import ${BuildEventsListenerRegistry.name}
            import ${OperationCompletionListener.name}
            import ${FinishEvent.name}
            import ${TaskFinishEvent.name}

	}
}

func (m *muxServer) unblockSend(seq uint32) {
	if !m.checkSeq(seq) {
		return
	}
	m.recvMu.Lock()
	defer m.recvMu.Unlock()
	if m.outBlock == nil {
		// Closed
		return
	}
	select {
	case m.outBlock <- struct{}{}:
	default:
		gridLogIf(m.ctx, errors.New("output unblocked overflow"))
	}
}

func (m *muxServer) ping(seq uint32) pongMsg {

	}

	if valueCount > 0.0 {
		return valueCount, nil
	}
	return 0, fmt.Errorf("value not found")
}

// Close implements io.Closer.
func (c *kubeComponent) Close() error {
	for _, forwarder := range c.forwarder {
		forwarder.Close()
	}
	return nil
}

type Query struct {
	Metric      string
	Aggregation string
	Labels      map[string]string
}

    /**
     * Called once per process, to register any globally scoped services. These services are reused across builds in the same process.
     * The services are closed when the process finishes.
     *
     * <p>Global services are visible to all other services.</p>
     *
     * @see Scope.Global
     */
    void registerGlobalServices(ServiceRegistration registration);

    /**
     * Declare an action to be run against this ZipEntry's content as a {@link InputStream}.
     * The {@link InputStream} passed to the {@link IoFunction#apply(Object)} will
     * be closed right after the action's return.
     *
     * This method or {@link #getContent()} may or may not support being called more than once per entry.
     * Use {@link #canReopen()} to determine if more than one call is supported.

    GitFileRepository submoduleRepo2 = new GitFileRepository("submodule2", tmpDir.testDirectory)

    // Directory clean up needs to happen after all of the repos have closed
    @Rule
    RuleChain rules = RuleChain.outerRule(tmpDir).around(repo).around(repo2).around(submoduleRepo).around(submoduleRepo2)

    def setup() {
        gitVcs = new GitVersionControlSystem()

	// If addr is not zero, Symbols restricts the list to symbols
	// containing that address.
	Symbols(r *regexp.Regexp, addr uint64) ([]*Sym, error)

	// Close closes the file, releasing associated resources.
	Close() error
}

// A Frame describes a single line in a source file.
type Frame struct {
	Func   string // name of function
	File   string // source file name

                rate(
                  istio_tcp_connections_opened_total{%(podLabels)s}
                [$__rate_interval])
              )
            |||
          ),
          self.query(
            'Closed ({{pod}})',
            |||
              -sum by (pod) (
                rate(
                  istio_tcp_connections_closed_total{%(podLabels)s}
                [$__rate_interval])
              )