}

    @Override
    public void close() {
        if (closed) {
            // Already closed.
            return;
        }
        closed = true;
        for (Loader value : loaders.values()) {
            IoActions.closeQuietly(value);
        }
    }

    private void ensureOpened() {
        if (closed) {

        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)

                    function() {
                      listSelNum =
                        $(this)
                          .closest("ol")
                          .children("li")
                          .index(this) + 1;
                      $(this)
                        .closest("ol")
                        .children("li")
                        .each(function(i) {

}

// Close closes the FD. The underlying file descriptor is closed by the
// destroy method when there are no remaining references.
func (fd *FD) Close() error {
	if !fd.fdmu.increfAndClose() {
		return errClosing(fd.isFile)
	}

	// Unblock any I/O.  Once it all unblocks and returns,
	// so that it cannot be referring to fd.sysfd anymore,
	// the final decref will close fd.sysfd. This should happen

    Closeables.closeQuietly(in);
    assertTrue(in.closed());
  }

  public void testCloseQuietly_readerWithEatenException() throws IOException {
    TestReader in = new TestReader(TestOption.CLOSE_THROWS);
    Closeables.closeQuietly(in);
    assertTrue(in.closed());
  }

  public void testCloseNull() throws IOException {
    Closeables.close(null, true);
    Closeables.close(null, false);
  }

	}()

	if ln, err := Listen("tcp", ""); err == nil {
		ln.Close()
	}
	if ln, err := ListenPacket("udp", ""); err == nil {
		ln.Close()
	}
	if ln, err := ListenTCP("tcp", nil); err == nil {
		ln.Close()
	}
	if ln, err := ListenUDP("udp", nil); err == nil {
		ln.Close()
	}
	if ln, err := ListenIP("ip:icmp", nil); err == nil {
		ln.Close()
	}
}

var ipv4MulticastListenerTests = []struct {

			skipOrFatalFn()
			continue
		}

		c1, err := ListenPacket(tt.net, tt.addr1)
		if err != nil {
			t.Fatal(err)
		}
		defer closer(c1, tt.net, tt.addr1, tt.addr2)
		c1.LocalAddr()

		c2, err := ListenPacket(tt.net, tt.addr2)
		if err != nil {
			t.Fatal(err)
		}
		defer closer(c2, tt.net, tt.addr1, tt.addr2)
		c2.LocalAddr()
		rb2 := make([]byte, 128)

		if _, err := c1.WriteTo(wb, c2.LocalAddr()); err != nil {

            def conn = event.create(serializer)
            conn.dispatch("bye")
            conn.stop()
            instant.closed
        } as Action, false)

        def connection = outgoingConnector.connect(acceptor.address).create(serializer)
        thread.blockUntil.closed

        then:
        connection.receive() == "bye"
        connection.receive() == null

        cleanup:

        else -> minOf(maxResult, delimiterIndex)
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true
      currentPart = null
      source.close()
    }

    /** A single part in a multipart body. */
    class Part(
      @get:JvmName("headers") val headers: Headers,

For more information about Gradle, please visit: https://gradle.org