server.listener.assertExhausted()
    server.source.close()
    client.source.close()
    taskFaker.runTasks()
    server.webSocket!!.tearDown()
    client.webSocket!!.tearDown()
    taskFaker.close()
  }

  @Test
  fun close() {
    client.webSocket!!.close(1000, "Hello!")
    // This will trigger a close response.
    assertThat(server.processNextFrame()).isFalse()

            cacheAccess.close()
        }

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot close cache access for <cache> as it is currently in use for 1 operations.'
        0 * _

        when:
        cacheAccess.close()

        then:
        1 * lock.close()
        0 * _
    }

	}
}

func TestSendfile(t *testing.T) {
	ln := newLocalListener(t, "tcp")
	defer ln.Close()

	errc := make(chan error, 1)
	go func(ln Listener) {
		// Wait for a connection.
		conn, err := ln.Accept()
		if err != nil {
			errc <- err
			close(errc)
			return
		}

		go func() {
			defer close(errc)
			defer conn.Close()

			f, err := os.Open(newton)
			if err != nil {
				errc <- err
				return

		f.Close()
		checkExists(t, "after File close")
		l1.Close()
		checkExists(t, "after FileListener close")
		l.Close()
		checkNotExists(t, "after Listener close")
	})

	// Only first call to l.Close should remove.
	t.Run("SecondClose", func(t *testing.T) {
		l := listen(t)
		checkExists(t, "after Listen")
		l.Close()
		checkNotExists(t, "after Listener close")

	go func() {
		defer close(serverDone)

		cs, err := ln.Accept()
		if err != nil {
			return
		}
		<-dialed
		cs.(*TCPConn).SetLinger(0)
		cs.Close()
	}()
	defer func() {
		ln.Close()
		<-serverDone
	}()

	ss, err := Dial("tcp", ln.Addr().String())
	close(dialed)
	if err != nil {
		t.Fatal(err)
	}
	defer ss.Close()

	_, err = ss.Read([]byte{0})

        _ * lock.state
        0 * _._

        when:
        access.close()

        then:
        _ * lock.state
        1 * cleanupExecutor.cleanup()
        1 * lock.close()
        0 * _._
    }

    def "acquires lock on open and releases on close when lock mode is exclusive"() {
        def access = newAccess(Exclusive)

        when:
        access.open()

        thrown(IllegalStateException)
    }

    def "can close a lock multiple times"() {
        given:
        def lock = createLock(Exclusive)
        lock.close()

        expect:
        lock.close()
    }

    def "cannot read from file after lock has been closed"() {
        given:
        def lock = createLock(Exclusive)
        lock.close()

        when:
        lock.readFile({} as Supplier)

	_, stop4 := createElection(t, "pod4", "green", watcher, false, client)
	close(stop2)
	close(stop3)
	close(stop4)
	// Now that revision "green" has stopped acting as leader, revision "red" should be able to claim lock.
	_, stop5 := createElection(t, "pod2", "red", watcher, true, client)
	close(stop5)
	close(stop)
	// Revision "green" can reclaim once "red" releases.

        synchronized(this) {
          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose as Close
        writer!!.writeClose(close.code, close.reason)

        // We closed the writer: now both reader and writer are closed.
        if (streamsToClose != null) {

			if err == nil {
				<-ctx.Done()
				c.Close()
			}
		}()
	}

	c, err := ln.Accept()
	if err == nil {
		c.Close()
	} else {
		t.Error(err)
	}
	time.Sleep(10 * time.Millisecond)
	cancel()
	wg.Wait()
	ln.Close()

	c, err = ln.Accept()
	if !errors.Is(err, ErrClosed) {
		if err == nil {
			c.Close()
		}
		t.Errorf("after l.Close(), l.Accept() = _, %v\nwant %v", err, ErrClosed)