/*
 * Copyright (c) 2011, 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 7105952 6322678 7082769
 * @summary Improve finalisation for FileInputStream/FileOutputStream/RandomAccessFile
 * @run main/othervm Sharing
 */

import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.util.concurrent.CountDownLatch;

public class Sharing {

    static final int numFiles = 10;
    static volatile boolean fail;

    public static void main(String[] args) throws Exception {
        TestFinalizer();
        TestMultipleFD();
        TestIsValid();
        MultiThreadedFD();
        TestCloseAll();
    }

    /**
     * Finalizer shouldn't discard a file descriptor until all streams have
     * finished with it.
     */
    private static void TestFinalizer() throws Exception {
        FileDescriptor fd = null;
        File tempFile = new File("TestFinalizer1.txt");
        tempFile.deleteOnExit();
        try (Writer writer = new FileWriter(tempFile)) {
            for (int i=0; i<5; i++) {
                writer.write("test file content test file content");
            }
        }

        FileInputStream fis1 = new FileInputStream(tempFile);
        fd = fis1.getFD();
        // Create a new FIS based on the existing FD (so the two FIS's share the same native fd)
        try (FileInputStream fis2 = new FileInputStream(fd)) {
            // allow fis1 to be gc'ed
            fis1 = null;
            int ret = 0;
            while(ret >= 0) {
                // encourage gc
                System.gc();
                // read from fis2 - when fis1 is gc'ed and finalizer is run, read will fail
                System.out.print(".");
                ret = fis2.read();
            }
        }

        // variation of above. Use RandomAccessFile to obtain a filedescriptor
        File testFinalizerFile = new File("TestFinalizer");
        RandomAccessFile raf = new RandomAccessFile(testFinalizerFile, "rw");
        raf.writeBytes("test file content test file content");
        raf.seek(0L);
        fd = raf.getFD();
        try (FileInputStream fis3 = new FileInputStream(fd)) {
            // allow raf to be gc'ed
            raf = null;
            int ret = 0;
            while (ret >= 0) {
                // encourage gc
                System.gc();
                /*
                 * read from fis3 - when raf is gc'ed and finalizer is run,
                 * fd should still be valid.
                 */
                System.out.print(".");
                ret = fis3.read();
            }
        } finally {
            testFinalizerFile.delete();
        }
    }

    /**
     * Exercise FileDispatcher close()/preClose()
     */
    private static void TestMultipleFD() throws Exception {
        RandomAccessFile raf = null;
        FileOutputStream fos = null;
        FileInputStream fis = null;
        FileChannel fc = null;
        FileLock fileLock = null;

        File test1 = new File("test1");
        try {
            raf = new RandomAccessFile(test1, "rw");
            fos = new FileOutputStream(raf.getFD());
            fis = new FileInputStream(raf.getFD());
            fc = raf.getChannel();
            fileLock = fc.lock();
            raf.setLength(0L);
            fos.flush();
            fos.write("TEST".getBytes());
        } finally {
            if (fileLock != null) fileLock.release();
            if (fis != null) fis.close();
            if (fos != null) fos.close();
            if (raf != null) raf.close();
            test1.delete();
        }

        /*
         * Close out in different order to ensure FD is not
         * closed out too early
         */
        File test2 = new File("test2");
        try {
            raf = new RandomAccessFile(test2, "rw");
            fos = new FileOutputStream(raf.getFD());
            fis = new FileInputStream(raf.getFD());
            fc = raf.getChannel();
            fileLock = fc.lock();
            raf.setLength(0L);
            fos.flush();
            fos.write("TEST".getBytes());
        } finally {
            if (fileLock != null) fileLock.release();
            if (raf != null) raf.close();
            if (fos != null) fos.close();
            if (fis != null) fis.close();
            test2.delete();
        }

        // one more time, fos first this time
        File test3 = new File("test3");
        try {
            raf = new RandomAccessFile(test3, "rw");
            fos = new FileOutputStream(raf.getFD());
            fis = new FileInputStream(raf.getFD());
            fc = raf.getChannel();
            fileLock = fc.lock();
            raf.setLength(0L);
            fos.flush();
            fos.write("TEST".getBytes());
        } finally {
            if (fileLock != null) fileLock.release();
            if (fos != null) fos.close();
            if (raf != null) raf.close();
            if (fis != null) fis.close();
            test3.delete();
        }
    }

    /**
     * Similar to TestMultipleFD() but this time we
     * just get and use FileDescriptor.valid() for testing.
     */
    private static void TestIsValid() throws Exception {
        FileDescriptor fd = null;
        RandomAccessFile raf = null;
        FileOutputStream fos = null;
        FileInputStream fis = null;
        FileChannel fc = null;

        File test1 = new File("test1");
        try {
            raf = new RandomAccessFile(test1, "rw");
            fd = raf.getFD();
            fos = new FileOutputStream(fd);
            fis = new FileInputStream(fd);
        } finally {
            try {
                if (fis != null) fis.close();
                if (fd.valid()) {
                    throw new RuntimeException("[FIS close()] FileDescriptor shouldn't be valid");
                }
                if (fos != null) fos.close();
                if (raf != null) raf.close();
            } finally {
                test1.delete();
            }
        }

        /*
         * Close out in different order to ensure FD is
         * closed correctly.
         */
        File test2 = new File("test2");
        try {
            raf = new RandomAccessFile(test2, "rw");
            fd = raf.getFD();
            fos = new FileOutputStream(fd);
            fis = new FileInputStream(fd);
        } finally {
            try {
                if (raf != null) raf.close();
                if (fd.valid()) {
                    throw new RuntimeException("[RAF close()] FileDescriptor shouldn't be valid");
                }
                if (fos != null) fos.close();
                if (fis != null) fis.close();
            } finally {
                test2.delete();
            }
        }

        // one more time, fos first this time
        File test3 = new File("test3");
        try {
            raf = new RandomAccessFile(test3, "rw");
            fd = raf.getFD();
            fos = new FileOutputStream(fd);
            fis = new FileInputStream(fd);
        } finally {
            try {
                if (fos != null) fos.close();
                if (fd.valid()) {
                    throw new RuntimeException("[FOS close()] FileDescriptor shouldn't be valid");
                }
                if (raf != null) raf.close();
                if (fis != null) fis.close();
            } finally {
                test3.delete();
            }
        }
    }

    /**
     * Test concurrent access to the same FileDescriptor
     */
    private static void MultiThreadedFD() throws Exception {
        RandomAccessFile raf = null;
        FileDescriptor fd = null;
        int numThreads = 2;
        CountDownLatch done = new CountDownLatch(numThreads);
        OpenClose[] fileOpenClose = new OpenClose[numThreads];
        File MultipleThreadedFD = new File("MultipleThreadedFD");
        try {
            raf = new RandomAccessFile(MultipleThreadedFD, "rw");
            fd = raf.getFD();
            for(int count=0;count<numThreads;count++) {
                fileOpenClose[count] = new OpenClose(fd, done);
                fileOpenClose[count].start();
            }
            done.await();
        } finally {
            try {
                if(raf != null) raf.close();
                // fd should now no longer be valid
                if(fd.valid()) {
                    throw new RuntimeException("FileDescriptor should not be valid");
                }
                // OpenClose thread tests failed
                if(fail) {
                    throw new RuntimeException("OpenClose thread tests failed.");
                }
            } finally {
                MultipleThreadedFD.delete();
            }
        }
    }

    /**
     * Test closeAll handling in FileDescriptor
     */
    private static void TestCloseAll() throws Exception {
        File testFile = new File("test");
        testFile.deleteOnExit();
        RandomAccessFile raf = new RandomAccessFile(testFile, "rw");
        FileInputStream fis = new FileInputStream(raf.getFD());
        fis.close();
        if (raf.getFD().valid()) {
             throw new RuntimeException("FD should not be valid.");
        }

        // Test the suppressed exception handling - FileInputStream

        raf = new RandomAccessFile(testFile, "rw");
        fis = new FileInputStream(raf.getFD());
        BadFileInputStream bfis1 = new BadFileInputStream(raf.getFD());
        BadFileInputStream bfis2 = new BadFileInputStream(raf.getFD());
        BadFileInputStream bfis3 = new BadFileInputStream(raf.getFD());
        // extra test - set bfis3 to null
        bfis3 = null;
        try {
            fis.close();
        } catch (IOException ioe) {
            ioe.printStackTrace();
            if (ioe.getSuppressed().length != 2) {
                throw new RuntimeException("[FIS]Incorrect number of suppressed " +
                          "exceptions received : " + ioe.getSuppressed().length);
            }
        }
        if (raf.getFD().valid()) {
            // we should still have closed the FD
            // even with the exception.
            throw new RuntimeException("[FIS]TestCloseAll : FD still valid.");
        }

        // Now test with FileOutputStream

        raf = new RandomAccessFile(testFile, "rw");
        FileOutputStream fos = new FileOutputStream(raf.getFD());
        BadFileOutputStream bfos1 = new BadFileOutputStream(raf.getFD());
        BadFileOutputStream bfos2 = new BadFileOutputStream(raf.getFD());
        BadFileOutputStream bfos3 = new BadFileOutputStream(raf.getFD());
        // extra test - set bfos3 to null
        bfos3 = null;
        try {
            fos.close();
        } catch (IOException ioe) {
            ioe.printStackTrace();
            if (ioe.getSuppressed().length != 2) {
                throw new RuntimeException("[FOS]Incorrect number of suppressed " +
                          "exceptions received : " + ioe.getSuppressed().length);
            }
        }
        if (raf.getFD().valid()) {
            // we should still have closed the FD
            // even with the exception.
            throw new RuntimeException("[FOS]TestCloseAll : FD still valid.");
        }
    }

    /**
     * A thread which will open and close a number of FileInputStreams and
     * FileOutputStreams referencing the same native file descriptor.
     */
    private static class OpenClose extends Thread {
        private FileDescriptor fd = null;
        private CountDownLatch done;
        FileInputStream[] fisArray = new FileInputStream[numFiles];
        FileOutputStream[] fosArray = new FileOutputStream[numFiles];

        OpenClose(FileDescriptor filedescriptor, CountDownLatch done) {
            this.fd = filedescriptor;
            this.done = done;
        }

        public void run() {
             try {
                 for(int i=0;i<numFiles;i++) {
                     fisArray[i] = new FileInputStream(fd);
                     fosArray[i] = new FileOutputStream(fd);
                 }

                 // Now close out
                 for(int i=0;i<numFiles;i++) {
                     if(fisArray[i] != null) fisArray[i].close();
                     if(fosArray[i] != null) fosArray[i].close();
                 }

             } catch(IOException ioe) {
                 System.out.println("OpenClose encountered IO issue :" + ioe);
                 fail = true;
             } finally {
                 if (fd.valid()) { // fd should not be valid after first close() call
                     System.out.println("OpenClose: FileDescriptor shouldn't be valid");
                     fail = true;
                 }
                 done.countDown();
             }
         }
    }

    private static class BadFileInputStream extends FileInputStream {

        BadFileInputStream(FileDescriptor fd) {
            super(fd);
        }

        public void close() throws IOException {
            throw new IOException("Bad close operation");
        }
    }

    private static class BadFileOutputStream extends FileOutputStream {

        BadFileOutputStream(FileDescriptor fd) {
            super(fd);
        }

        public void close() throws IOException {
            throw new IOException("Bad close operation");
        }
    }

}