/*

 * Copyright (c) 2008, 2017, 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 4313887 6838333 6917021 7006126 6950237 8006645

 * @summary Unit test for java.nio.file.Files copy and move methods (use -Dseed=X to set PRNG seed)

 * @library .. /test/lib

 * @build jdk.test.lib.RandomFactory

 *        CopyAndMove PassThroughFileSystem

 * @run main/othervm CopyAndMove

 * @key randomness

 */

import java.nio.ByteBuffer;

import java.nio.file.*;

import static java.nio.file.Files.*;

import static java.nio.file.StandardCopyOption.*;

import static java.nio.file.LinkOption.*;

import java.nio.file.attribute.*;

import java.io.*;

import java.util.*;

import java.util.concurrent.TimeUnit;

import jdk.test.lib.RandomFactory;

public class CopyAndMove {

    static final Random rand = RandomFactory.getRandom();

    static boolean heads() { return rand.nextBoolean(); }

    private static boolean testPosixAttributes = false;

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

        Path dir1 = TestUtil.createTemporaryDirectory();

        try {

            // Same directory

            testPosixAttributes = getFileStore(dir1).supportsFileAttributeView("posix");

            testCopyFileToFile(dir1, dir1, TestUtil.supportsLinks(dir1));

            testMove(dir1, dir1, TestUtil.supportsLinks(dir1));

            // Different directories. Use test.dir if possible as it might be

            // a different volume/file system and so improve test coverage.

            String testDir = System.getProperty("test.dir", ".");

            Path dir2 = TestUtil.createTemporaryDirectory(testDir);

            try {

                boolean testSymbolicLinks =

                    TestUtil.supportsLinks(dir1) && TestUtil.supportsLinks(dir2);

                testPosixAttributes = getFileStore(dir1).supportsFileAttributeView("posix") &&

                                      getFileStore(dir2).supportsFileAttributeView("posix");

                testCopyFileToFile(dir1, dir2, testSymbolicLinks);

                testMove(dir1, dir2, testSymbolicLinks);

            } finally {

                TestUtil.removeAll(dir2);

            }

            // Target is location associated with custom provider

            Path dir3 = PassThroughFileSystem.create().getPath(dir1.toString());

            testPosixAttributes = getFileStore(dir1).supportsFileAttributeView("posix") &&

                                  getFileStore(dir3).supportsFileAttributeView("posix");

            testCopyFileToFile(dir1, dir3, false);

            testMove(dir1, dir3, false);

            // Test copy(InputStream,Path) and copy(Path,OutputStream)

            testCopyInputStreamToFile();

            testCopyFileToOuputStream();

        } finally {

            TestUtil.removeAll(dir1);

        }

    }

    static void checkBasicAttributes(BasicFileAttributes attrs1,

                                     BasicFileAttributes attrs2)

    {

        // check file type

        assertTrue(attrs1.isRegularFile() == attrs2.isRegularFile());

        assertTrue(attrs1.isDirectory() == attrs2.isDirectory());

        assertTrue(attrs1.isSymbolicLink() == attrs2.isSymbolicLink());

        assertTrue(attrs1.isOther() == attrs2.isOther());

        // check last modified time if not a symbolic link

        if (!attrs1.isSymbolicLink()) {

            long time1 = attrs1.lastModifiedTime().to(TimeUnit.SECONDS);

            long time2 = attrs2.lastModifiedTime().to(TimeUnit.SECONDS);

            if (time1 != time2) {

                System.err.format("File time for %s is %s\n", attrs1.fileKey(), attrs1.lastModifiedTime());

                System.err.format("File time for %s is %s\n", attrs2.fileKey(), attrs2.lastModifiedTime());

                assertTrue(false);

            }

        }

        // check size

        if (attrs1.isRegularFile())

            assertTrue(attrs1.size() == attrs2.size());

    }

    static void checkPosixAttributes(PosixFileAttributes attrs1,

                                     PosixFileAttributes attrs2)

    {

        assertTrue(attrs1.permissions().equals(attrs2.permissions()));

        assertTrue(attrs1.owner().equals(attrs2.owner()));

        assertTrue(attrs1.group().equals(attrs2.group()));

    }

    static void checkDosAttributes(DosFileAttributes attrs1,

                                   DosFileAttributes attrs2)

    {

        assertTrue(attrs1.isReadOnly() == attrs2.isReadOnly());

        assertTrue(attrs1.isHidden() == attrs2.isHidden());

        assertTrue(attrs1.isSystem() == attrs2.isSystem());

    }

    static void checkUserDefinedFileAttributes(Map<String,ByteBuffer> attrs1,

                                     Map<String,ByteBuffer> attrs2)

    {

        assert attrs1.size() == attrs2.size();

        for (String name: attrs1.keySet()) {

            ByteBuffer bb1 = attrs1.get(name);

            ByteBuffer bb2 = attrs2.get(name);

            assertTrue(bb2 != null);

            assertTrue(bb1.equals(bb2));

        }

    }

    static Map<String,ByteBuffer> readUserDefinedFileAttributes(Path file)

        throws IOException

    {

        UserDefinedFileAttributeView view =

            getFileAttributeView(file, UserDefinedFileAttributeView.class);

        Map<String,ByteBuffer> result = new HashMap<>();

        for (String name: view.list()) {

            int size = view.size(name);

            ByteBuffer bb = ByteBuffer.allocate(size);

            int n = view.read(name, bb);

            assertTrue(n == size);

            bb.flip();

            result.put(name, bb);

        }

        return result;

    }

    // move source to target with verification

    static void moveAndVerify(Path source, Path target, CopyOption... options)

        throws IOException

    {

        // read attributes before file is moved

        BasicFileAttributes basicAttributes = null;

        PosixFileAttributes posixAttributes = null;

        DosFileAttributes dosAttributes = null;

        Map<String,ByteBuffer> namedAttributes = null;

        // get file attributes of source file

        String os = System.getProperty("os.name");

        if (os.startsWith("Windows")) {

            dosAttributes = readAttributes(source, DosFileAttributes.class, NOFOLLOW_LINKS);

            basicAttributes = dosAttributes;

        } else {

            posixAttributes = readAttributes(source, PosixFileAttributes.class, NOFOLLOW_LINKS);

            basicAttributes = posixAttributes;

        }

        if (basicAttributes == null)

            basicAttributes = readAttributes(source, BasicFileAttributes.class, NOFOLLOW_LINKS);

        // hash file contents if regular file

        int hash = (basicAttributes.isRegularFile()) ? computeHash(source) : 0;

        // record link target if symbolic link

        Path linkTarget = null;

        if (basicAttributes.isSymbolicLink())

            linkTarget = readSymbolicLink(source);

        // read named attributes if available (and file is not a sym link)

        if (!basicAttributes.isSymbolicLink() &&

            getFileStore(source).supportsFileAttributeView("xattr"))

        {

            namedAttributes = readUserDefinedFileAttributes(source);

        }

        // move file

        Path result = move(source, target, options);

        assertTrue(result == target);

        // verify source does not exist

        assertTrue(notExists(source));

        // verify file contents

        if (basicAttributes.isRegularFile()) {

            if (computeHash(target) != hash)

                throw new RuntimeException("Failed to verify move of regular file");

        }

        // verify link target

        if (basicAttributes.isSymbolicLink()) {

            if (!readSymbolicLink(target).equals(linkTarget))

                throw new RuntimeException("Failed to verify move of symbolic link");

        }

        // verify basic attributes

        checkBasicAttributes(basicAttributes,

            readAttributes(target, BasicFileAttributes.class, NOFOLLOW_LINKS));

        // verify other attributes when same provider

        if (source.getFileSystem().provider() == target.getFileSystem().provider()) {

            // verify POSIX attributes

            if (posixAttributes != null &&

                !basicAttributes.isSymbolicLink() &&

                testPosixAttributes)

            {

                checkPosixAttributes(posixAttributes,

                    readAttributes(target, PosixFileAttributes.class, NOFOLLOW_LINKS));

            }

            // verify DOS attributes

            if (dosAttributes != null && !basicAttributes.isSymbolicLink()) {

                DosFileAttributes attrs =

                    readAttributes(target, DosFileAttributes.class, NOFOLLOW_LINKS);

                checkDosAttributes(dosAttributes, attrs);

            }

            // verify named attributes

            if (namedAttributes != null &&

                getFileStore(target).supportsFileAttributeView("xattr"))

            {

                checkUserDefinedFileAttributes(namedAttributes,

                                               readUserDefinedFileAttributes(target));

            }

        }

    }

    /**

     * Tests all possible ways to invoke move

     */

    static void testMove(Path dir1, Path dir2, boolean supportsLinks)

        throws IOException

    {

        Path source, target, entry;

        boolean sameDevice = getFileStore(dir1).equals(getFileStore(dir2));

        // -- regular file --

        /**

         * Test: move regular file, target does not exist

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target);

        delete(target);

        /**

         * Test: move regular file, target exists

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        createFile(target);

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        delete(target);

        createDirectory(target);

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        delete(source);

        delete(target);

        /**

         * Test: move regular file, target does not exist

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move regular file, target exists

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        createFile(target);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move regular file, target exists and is empty directory

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        createDirectory(target);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move regular file, target exists and is non-empty directory

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        createDirectory(target);

        entry = target.resolve("foo");

        createFile(entry);

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        delete(entry);

        delete(source);

        delete(target);

        /**

         * Test atomic move of regular file (same file store)

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir1);

        moveAndVerify(source, target, ATOMIC_MOVE);

        delete(target);

        /**

         * Test atomic move of regular file (different file store)

         */

        if (!sameDevice) {

            source = createSourceFile(dir1);

            target = getTargetFile(dir2);

            try {

                moveAndVerify(source, target, ATOMIC_MOVE);

                throw new RuntimeException("AtomicMoveNotSupportedException expected");

            } catch (AtomicMoveNotSupportedException x) {

            }

            delete(source);

        }

        // -- directories --

        /*

         * Test: move empty directory, target does not exist

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target);

        delete(target);

        /**

         * Test: move empty directory, target exists

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        createFile(target);

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        delete(target);

        createDirectory(target);

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        delete(source);

        delete(target);

        /**

         * Test: move empty directory, target does not exist

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move empty directory, target exists

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        createFile(target);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move empty, target exists and is empty directory

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        createDirectory(target);

        moveAndVerify(source, target, REPLACE_EXISTING);

        delete(target);

        /**

         * Test: move empty directory, target exists and is non-empty directory

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        createDirectory(target);

        entry = target.resolve("foo");

        createFile(entry);

        try {

            moveAndVerify(source, target, REPLACE_EXISTING);

            throw new RuntimeException("DirectoryNotEmptyException expected");

        } catch (DirectoryNotEmptyException x) {

        }

        delete(entry);

        delete(source);

        delete(target);

        /**

         * Test: move non-empty directory (same file system)

         */

        source = createSourceDirectory(dir1);

        createFile(source.resolve("foo"));

        target = getTargetFile(dir1);

        moveAndVerify(source, target);

        delete(target.resolve("foo"));

        delete(target);

        /**

         * Test: move non-empty directory (different file store)

         */

        if (!sameDevice) {

            source = createSourceDirectory(dir1);

            createFile(source.resolve("foo"));

            target = getTargetFile(dir2);

            try {

                moveAndVerify(source, target);

                throw new RuntimeException("IOException expected");

            } catch (IOException x) {

            }

            delete(source.resolve("foo"));

            delete(source);

        }

        /**

         * Test atomic move of directory (same file store)

         */

        source = createSourceDirectory(dir1);

        createFile(source.resolve("foo"));

        target = getTargetFile(dir1);

        moveAndVerify(source, target, ATOMIC_MOVE);

        delete(target.resolve("foo"));

        delete(target);

        // -- symbolic links --

        /**

         * Test: Move symbolic link to file, target does not exist

         */

        if (supportsLinks) {

            Path tmp = createSourceFile(dir1);

            source = dir1.resolve("link");

            createSymbolicLink(source, tmp);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            delete(target);

            delete(tmp);

        }

        /**

         * Test: Move symbolic link to directory, target does not exist

         */

        if (supportsLinks) {

            source = dir1.resolve("link");

            createSymbolicLink(source, dir2);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            delete(target);

        }

        /**

         * Test: Move broken symbolic link, target does not exists

         */

        if (supportsLinks) {

            Path tmp = Paths.get("doesnotexist");

            source = dir1.resolve("link");

            createSymbolicLink(source, tmp);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            delete(target);

        }

        /**

         * Test: Move symbolic link, target exists

         */