/*

 * 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

 * @summary Unit test for java.nio.file.Path copyTo/moveTo methods

 * @library ..

 * @build CopyAndMove PassThroughFileSystem

 * @run main/othervm CopyAndMove

 */

import java.nio.ByteBuffer;

import java.nio.file.*;

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

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

import java.nio.file.attribute.*;

import java.io.*;

import java.util.*;

public class CopyAndMove {

    static final Random rand = new Random();

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

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

        Path dir1 = TestUtil.createTemporaryDirectory();

        try {

            // Same directory

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

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

                doCopyTests(dir1, dir2, testSymbolicLinks);

                doMoveTests(dir1, dir2, testSymbolicLinks);

            } finally {

                TestUtil.removeAll(dir2);

            }

            // Target is location associated with custom provider

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

            doCopyTests(dir1, dir3, false);

            doMoveTests(dir1, dir3, false);

        } 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

        long time1 = attrs1.lastModifiedTime().toMillis();

        long time2 = attrs2.lastModifiedTime().toMillis();

        assertTrue(time1 == time2);

        // 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 = file

            .getFileAttributeView(UserDefinedFileAttributeView.class);

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

        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.equals("SunOS") || os.equals("Linux")) {

            posixAttributes = Attributes.readPosixFileAttributes(source, NOFOLLOW_LINKS);

            basicAttributes = posixAttributes;

        }

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

            dosAttributes = Attributes.readDosFileAttributes(source, NOFOLLOW_LINKS);

            basicAttributes = dosAttributes;

        }

        if (basicAttributes == null)

            basicAttributes = Attributes.readBasicFileAttributes(source, 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 = source.readSymbolicLink();

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

        if (!basicAttributes.isSymbolicLink() &&

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

        {

            namedAttributes = readUserDefinedFileAttributes(source);

        }

        // move file

        source.moveTo(target, options);

        // verify source does not exist

        assertTrue(source.notExists());

        // 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 (!target.readSymbolicLink().equals(linkTarget))

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

        }

        // verify basic attributes

        checkBasicAttributes(basicAttributes,

            Attributes.readBasicFileAttributes(target, NOFOLLOW_LINKS));

        // verify other attributes when same provider

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

            // verify POSIX attributes

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

                checkPosixAttributes(posixAttributes,

                    Attributes.readPosixFileAttributes(target, NOFOLLOW_LINKS));

            }

            // verify DOS attributes

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

                checkDosAttributes(dosAttributes,

                    Attributes.readDosFileAttributes(target, NOFOLLOW_LINKS));

            }

            // verify named attributes

            if (namedAttributes != null &&

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

            {

                checkUserDefinedFileAttributes(namedAttributes,

                                               readUserDefinedFileAttributes(target));

            }

        }

    }

    /**

     * Tests all possible ways to invoke moveTo

     */

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

        throws IOException

    {

        Path source, target, entry;

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

        // -- regular file --

        /**

         * Test: move regular file, target does not exist

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target);

        target.delete();

        /**

         * Test: move regular file, target exists

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2).createFile();

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        target.delete();

        target.createDirectory();

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        source.delete();

        target.delete();

        /**

         * Test: move regular file, target does not exist

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

         * Test: move regular file, target exists

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2).createFile();

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

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

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2).createDirectory();

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

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

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir2).createDirectory();

        entry = target.resolve("foo").createFile();

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        entry.delete();

        source.delete();

        target.delete();

        /**

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

         */

        source = createSourceFile(dir1);

        target = getTargetFile(dir1);

        moveAndVerify(source, target, ATOMIC_MOVE);

        target.delete();

        /**

         * 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) {

            }

            source.delete();

        }

        // -- directories --

        /*

         * Test: move empty directory, target does not exist

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target);

        target.delete();

        /**

         * Test: move empty directory, target exists

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2).createFile();

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        target.delete();

        target.createDirectory();

        try {

            moveAndVerify(source, target);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        source.delete();

        target.delete();

        /**

         * Test: move empty directory, target does not exist

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2);

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

         * Test: move empty directory, target exists

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2).createFile();

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

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

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2).createDirectory();

        moveAndVerify(source, target, REPLACE_EXISTING);

        target.delete();

        /**

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

         */

        source = createSourceDirectory(dir1);

        target = getTargetFile(dir2).createDirectory();

        entry = target.resolve("foo").createFile();

        try {

            moveAndVerify(source, target, REPLACE_EXISTING);

            throw new RuntimeException("FileAlreadyExistsException expected");

        } catch (FileAlreadyExistsException x) {

        }

        entry.delete();

        source.delete();

        target.delete();

        /**

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

         */

        source = createSourceDirectory(dir1);

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

        target = getTargetFile(dir1);

        moveAndVerify(source, target);

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

        target.delete();

        /**

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

         */

        if (!sameDevice) {

            source = createSourceDirectory(dir1);

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

            target = getTargetFile(dir2);

            try {

                moveAndVerify(source, target);

                throw new RuntimeException("IOException expected");

            } catch (IOException x) {

            }

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

            source.delete();

        }

        /**

         * Test atomic move of directory (same file store)

         */

        source = createSourceDirectory(dir1);

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

        target = getTargetFile(dir1);

        moveAndVerify(source, target, ATOMIC_MOVE);

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

        target.delete();

        // -- symbolic links --

        /**

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

         */

        if (supportsLinks) {

            Path tmp = createSourceFile(dir1);

            source = dir1.resolve("link").createSymbolicLink(tmp);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            target.delete();

            tmp.delete();

        }

        /**

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

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir2);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            target.delete();

        }

        /**

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

         */

        if (supportsLinks) {

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

            source = dir1.resolve("link").createSymbolicLink(tmp);

            target = getTargetFile(dir2);

            moveAndVerify(source, target);

            target.delete();

        }

        /**

         * Test: Move symbolic link, target exists

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir2);

            target = getTargetFile(dir2).createFile();

            try {

                moveAndVerify(source, target);

                throw new RuntimeException("FileAlreadyExistsException expected");

            } catch (FileAlreadyExistsException x) {

            }

            source.delete();

            target.delete();

        }

        /**

         * Test: Move regular file, target exists

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir2);

            target = getTargetFile(dir2).createFile();

            moveAndVerify(source, target, REPLACE_EXISTING);

            target.delete();

        }

        /**

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

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir2);

            target = getTargetFile(dir2).createDirectory();

            moveAndVerify(source, target, REPLACE_EXISTING);

            target.delete();

        }

        /**

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

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir2);

            target = getTargetFile(dir2).createDirectory();

            entry = target.resolve("foo").createFile();

            try {

                moveAndVerify(source, target);

                throw new RuntimeException("FileAlreadyExistsException expected");

            } catch (FileAlreadyExistsException x) {

            }

            entry.delete();

            source.delete();

            target.delete();

        }

        /**

         * Test atomic move of symbolic link (same file store)

         */

        if (supportsLinks) {

            source = dir1.resolve("link").createSymbolicLink(dir1);