/*

 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/**

 * @test

 * @bug 8212132

 * @summary Test that DatagramChannel does not leak file descriptors

 * @requires os.family != "windows"

 * @modules jdk.management

 * @library /test/lib

 * @run main/othervm Unref

 */

import java.io.IOException;

import java.lang.management.ManagementFactory;

import java.net.InetSocketAddress;

import java.net.StandardProtocolFamily;

import java.nio.channels.DatagramChannel;

import java.nio.channels.SelectionKey;

import java.nio.channels.Selector;

import com.sun.management.UnixOperatingSystemMXBean;

import jtreg.SkippedException;

import jdk.test.lib.net.IPSupport;

public class Unref {

    interface DatagramChannelSupplier {

        DatagramChannel get() throws IOException;

    }

    public static void main(String[] args) throws Exception {

        if (unixOperatingSystemMXBean() == null)

            throw new SkippedException("This test requires UnixOperatingSystemMXBean");

        test(DatagramChannel::open);

        if (IPSupport.hasIPv4())

            test(() -> DatagramChannel.open(StandardProtocolFamily.INET));

        if (IPSupport.hasIPv6())

            test(() -> DatagramChannel.open(StandardProtocolFamily.INET6));

    }

    static void test(DatagramChannelSupplier supplier) throws Exception {

        openAndClose(supplier); // warm-up

        try (Selector sel = Selector.open()) {

            long count = fileDescriptorCount();

            // open+close

            openAndClose(supplier);

            assertEquals(fileDescriptorCount(), count);

            // open+unref, file descriptor should be closed by cleaner

            openAndUnref(supplier);

            assertEquals(waitForFileDescriptorCount(count), count);

            // open+register+close+flush

            openRegisterAndClose(supplier, sel);

            assertEquals(fileDescriptorCount(), count);

            // open+register+flush, file descriptor should be closed by cleaner

            openRegisterAndUnref(supplier, sel);

            assertEquals(waitForFileDescriptorCount(count), count);

        }

    }

    /**

     * Create a DatagramChannel and closes it.

     */

    static void openAndClose(DatagramChannelSupplier supplier) throws IOException {

        System.out.println("openAndClose ...");

        DatagramChannel dc = supplier.get();

        dc.close();

    }

    /**

     * Create a DatagramChannel and exits without closing the channel.

     */

    static void openAndUnref(DatagramChannelSupplier supplier) throws IOException {

        System.out.println("openAndUnref ...");

        DatagramChannel dc = supplier.get();

    }

    /**

     * Create a DatagramChannel, register it with a Selector, close the channel

     * while register, and then finally flush the channel from the Selector.

     */

    static void openRegisterAndClose(DatagramChannelSupplier supplier, Selector sel)

        throws IOException

    {

        System.out.println("openRegisterAndClose ...");

        try (DatagramChannel dc = supplier.get()) {

            dc.bind(new InetSocketAddress(0));

            dc.configureBlocking(false);

            dc.register(sel, SelectionKey.OP_READ);

            sel.selectNow();

        }

        // flush, should close channel

        sel.selectNow();

    }

    /**

     * Creates a DatagramChannel, registers with a Selector, cancels the key

     * and flushes the channel from the Selector. This method exits without

     * closing the channel.

     */

    static void openRegisterAndUnref(DatagramChannelSupplier supplier, Selector sel)

        throws IOException

    {

        System.out.println("openRegisterAndUnref ...");

        DatagramChannel dc = supplier.get();

        dc.bind(new InetSocketAddress(0));

        dc.configureBlocking(false);

        SelectionKey key = dc.register(sel, SelectionKey.OP_READ);

        sel.selectNow();

        key.cancel();

        sel.selectNow();

    }

    /**

     * If the file descriptor count is higher than the given count then invoke

     * System.gc() and wait for the file descriptor count to drop.

     */

    static long waitForFileDescriptorCount(long target) throws InterruptedException {

        long actual = fileDescriptorCount();

        if (actual > target) {

            System.gc();

            while ((actual = fileDescriptorCount()) > target) {

                Thread.sleep(10);

            }

        }

        return actual;

    }

    static UnixOperatingSystemMXBean unixOperatingSystemMXBean() {

        return ManagementFactory.getPlatformMXBean(UnixOperatingSystemMXBean.class);

    }

    static long fileDescriptorCount() {

        return unixOperatingSystemMXBean().getOpenFileDescriptorCount();

    }

    static void assertEquals(long actual, long expected) {

        if (actual != expected)

            throw new RuntimeException("actual=" + actual + ", expected=" + expected);

    }

}