* This may happen because the peer has signalled that it has finished sending messages, or closes the connection, or crashes. It may also happen when
     * this side of the connection is closed using {@link ObjectConnection#stop()}.
     * </p>
     *

	// * an error on failure of unlock request operation.
	ForceUnlock(ctx context.Context, args LockArgs) (bool, error)

	// Returns underlying endpoint of this lock client instance.
	String() string

	// Close closes any underlying connection to the service endpoint
	Close() error

	// Is the underlying connection online? (is always true for any local lockers)
	IsOnline() bool

	// Is the underlying locker local to this server?

	closeErr error
	closed   bool

	// to avoid allocations
	buf bytes.Buffer
	h   header
}

func newConn(rwc io.ReadWriteCloser) *conn {
	return &conn{rwc: rwc}
}

// Close closes the conn if it is not already closed.
func (c *conn) Close() error {
	c.mutex.Lock()
	defer c.mutex.Unlock()
	if !c.closed {
		c.closeErr = c.rwc.Close()
		c.closed = true
	}
	return c.closeErr
}

        value = "Some message"
    }

    def "returns null when accessing value of a non existing header"() {
        expect:
        resource().getHeaderValue("X-No-Such-Header") == null
    }

    def "close closes the response"() {
        given:
        def mockedHttpResponse = mockedHttpResponse(response)

        when:
        resource().close()

        then:
        interaction {

  # has no effect on outbound traffic: iptables REDIRECT is always used for
  # outbound connections.
  # If "REDIRECT", use iptables REDIRECT to NAT and redirect to Envoy.
  # The "REDIRECT" mode loses source addresses during redirection.
  # If "TPROXY", use iptables TPROXY to redirect to Envoy.
  # The "TPROXY" mode preserves both the source and destination IP

     */
    fun loadOrCreateProjectMetadata(identityPath: Path, creator: () -> LocalComponentGraphResolveState): LocalComponentGraphResolveState

    /**
     * Flushes any remaining state to the cache and closes any resources
     */
    fun finalizeCacheEntry()

    // This is a temporary property to allow migration from a root build scoped cache to a build tree scoped cache
    val isLoaded: Boolean

			// If ServeHTTP panics, the server (the caller of ServeHTTP) assumes
			// that the effect of the panic was isolated to the active request.
			// It recovers the panic, logs a stack trace to the server error log,
			// and either closes the network connection or sends an HTTP/2
			// RST_STREAM, depending on the HTTP protocol. To abort a handler so
			// the client sees an interrupted response but the server doesn't log

	UID       interface{}
	AddedAt   time.Time
	ProcessAt time.Time
}

// now is used to test time
var now = time.Now

// TimedQueue is a priority heap where the lowest ProcessAt is at the front of the queue
type TimedQueue []*TimedValue

// Len is the length of the queue.
func (h TimedQueue) Len() int { return len(h) }

// Less returns true if queue[i] < queue[j].

    advance();
  }

  @Override
  public void close() throws IOException {
    if (in != null) {
      try {
        in.close();
      } finally {
        in = null;
      }
    }
  }

  /** Closes the current input stream and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      in = it.next().openStream();
    }
  }

  @Override

            LOGGER.debug("Exception while consuming empty object content from metadata request", e);
        } finally {
            // This also closes objectContent, no need to close it explicitly.
            IoActions.closeQuietly(s3Object);
        }
    }

    @Override