/*

 * Copyright (c) 2002, 2013, 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 4759207 4403166 4165006 4403166 6182812 6274272 7160013

   @summary Test to see if win32 path length can be greater than 260

 */

import java.io.*;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.DirectoryNotEmptyException;

public class MaxPathLength {

    private static String sep = File.separator;

    private static String pathComponent = sep +

        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";

    private static String fileName =

                 "areallylongfilenamethatsforsur";

    private static boolean isWindows = false;

    private final static int MAX_LENGTH = 256;

    private static int counter = 0;

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

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

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

            isWindows = true;

        }

        for (int i = 4; i < 7; i++) {

            String name = fileName;

            while (name.length() < MAX_LENGTH) {

                testLongPath (i, name, false);

                testLongPath (i, name, true);

                name = getNextName(name);

            }

        }

        // test long paths on windows

        // And these long pathes cannot be handled on Solaris and Mac platforms

        if (isWindows) {

            String name = fileName;

            while (name.length() < MAX_LENGTH) {

                testLongPath (20, name, false);

                testLongPath (20, name, true);

                name = getNextName(name);

            }

        }

    }

    private static String getNextName(String fName) {

        return (fName.length() < MAX_LENGTH/2) ? fName + fName

                                               : fName + "A";

    }

    static void testLongPath(int max, String fn,

                             boolean tryAbsolute) throws Exception {

        String[] created = new String[max];

        String pathString = ".";

        for (int i = 0; i < max -1; i++) {

            pathString = pathString + pathComponent + (counter++);

            created[max - 1 -i] = pathString;

        }

        File dirFile = new File(pathString);

        File f = new File(pathString + sep + fn);

        String tPath = f.getPath();

        if (tryAbsolute) {

            tPath = f.getCanonicalPath();

        }

        created[0] = tPath;

        //for getCanonicalPath testing on win32

        File fu = new File(pathString + sep + fn.toUpperCase());

        if (dirFile.exists()) {

            System.err.println("Warning: Test directory structure exists already!");

            return;

        }

        try {

            Files.createDirectories(dirFile.toPath());

            if (tryAbsolute)

                dirFile = new File(dirFile.getCanonicalPath());

            if (!dirFile.isDirectory())

                throw new RuntimeException ("File.isDirectory() failed");

            f = new File(tPath);

            if (!f.createNewFile()) {

                throw new RuntimeException ("File.createNewFile() failed");

            }

            if (!f.exists())

                throw new RuntimeException ("File.exists() failed");

            if (!f.isFile())

                throw new RuntimeException ("File.isFile() failed");

            if (!f.canRead())

                throw new RuntimeException ("File.canRead() failed");

            if (!f.canWrite())

                throw new RuntimeException ("File.canWrite() failed");

            if (!f.delete())

                throw new RuntimeException ("File.delete() failed");

            FileOutputStream fos = new FileOutputStream(f);

            fos.write(1);

            fos.close();

            if (f.length() != 1)

                throw new RuntimeException ("File.length() failed");

            long time = System.currentTimeMillis();

            if (!f.setLastModified(time))

                throw new RuntimeException ("File.setLastModified() failed");

            if (f.lastModified() == 0) {

                throw new RuntimeException ("File.lastModified() failed");

            }

            String[] list = dirFile.list();

            if (list == null || !fn.equals(list[0])) {

                throw new RuntimeException ("File.list() failed");

            }

            File[] flist = dirFile.listFiles();

            if (flist == null || !fn.equals(flist[0].getName()))

                throw new RuntimeException ("File.listFiles() failed");

            if (isWindows &&

                !fu.getCanonicalPath().equals(f.getCanonicalPath()))

                throw new RuntimeException ("getCanonicalPath() failed");

            char[] cc = tPath.toCharArray();

            cc[cc.length-1] = 'B';

            File nf = new File(new String(cc));

            if (!f.renameTo(nf)) {

                /*there is a known issue that renameTo fails if

                  (1)the path is a UNC path and

                  (2)the path length is bigger than 1092

                  so don't stop if above are true

                */

                String abPath = f.getAbsolutePath();

                if (!abPath.startsWith("\\\\") ||

                    abPath.length() < 1093) {

                    throw new RuntimeException ("File.renameTo() failed for lenth="

                                                + abPath.length());

                }

            } else {

                if (!nf.canRead())

                    throw new RuntimeException ("Renamed file is not readable");

                if (!nf.canWrite())

                    throw new RuntimeException ("Renamed file is not writable");

                if (nf.length() != 1)

                    throw new RuntimeException ("Renamed file's size is not correct");

                if (!nf.renameTo(f)) {

                    created[0] = nf.getPath();

                }

                /* add a script to test these two if we got a regression later

                if (!f.setReadOnly())

                    throw new RuntimeException ("File.setReadOnly() failed");

                f.deleteOnExit();

                */

            }

        } finally {

            // Clean up

            for (int i = 0; i < max; i++) {

                Path p = (new File(created[i])).toPath();

                try {

                    Files.deleteIfExists(p);

                    // Test if the file is really deleted and wait for 1 second at most

                    for (int j = 0; j < 10 && Files.exists(p); j++) {

                        Thread.sleep(100);

                    }

                } catch (DirectoryNotEmptyException ex) {

                    // Give up the clean-up, let jtreg handle it.

                    System.err.println("Dir, " + p + ", is not empty");

                    break;

                }

            }

        }

    }

}