"io"

	xioutil "github.com/minio/minio/internal/ioutil"
)

// DrainBody close non nil response with any response Body.
// convenient wrapper to drain any remaining data on response body.
//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.

    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()

	}
	return false
}

func main() {
	if !close(0., 0, 1, 0) {
		print("0. is ", 0., "\n")
	}
	if !close(+10., 10, 1, 0) {
		print("+10. is ", +10., "\n")
	}
	if !close(-210., -210, 1, 0) {
		print("-210. is ", -210., "\n")
	}

	if !close(.0, 0, 1, 0) {
		print(".0 is ", .0, "\n")
	}
	if !close(+.01, 1, 100, 0) {
		print("+.01 is ", +.01, "\n")
	}
	if !close(-.012, -12, 1000, 0) {

            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 * _
    }

		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")

	}
}

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

		if !close(-f1, f3) || !close(g1, g3) {
			t.Errorf("Sincos(%g) = %g, %g, want %g, %g", -trigHuge[i], f3, g3, -f1, g1)
		}
	}
}

func TestHugeTan(t *testing.T) {
	for i := 0; i < len(trigHuge); i++ {
		f1 := tanHuge[i]
		f2 := Tan(trigHuge[i])
		if !close(f1, f2) {
			t.Errorf("Tan(%g) = %g, want %g", trigHuge[i], f2, f1)
		}
		f3 := Tan(-trigHuge[i])
		if !close(-f1, f3) {

        def beforeAccess = lock.state
        lock.close()

        and:
        lock = createLock(lockMode, testFile, lockManager)
        lock.readFile {}
        lock.close()

        when:
        lock = createLock(lockMode)

        then:
        !lock.state.hasBeenUpdatedSince(beforeAccess)

        cleanup:
        lock?.close()

        where:
        lockMode << [Exclusive, Shared]

        e.cause.class == SomeException

        cleanup:
        data.close()
        store.close()
    }

    def "may be empty"() {
        def store = new DefaultBinaryStore(temp.file("foo.bin"))

        when:
        def data = store.done()
        store.close()

        then:
        data.close()
    }

		case "unix", "unixpacket":
			defer ln1.Close() // UnixListener.Close calls syscall.Unlink internally
		default:
			if err := ln1.Close(); err != nil {
				t.Error(err)
			}
		}
		if err != nil {
			if perr := parseCommonError(err); perr != nil {
				t.Error(perr)
			}
			t.Fatal(err)
		}

		ln2, err := FileListener(f)
		if err := f.Close(); err != nil {
			t.Error(err)
		}