/*

 * Copyright (c) 2016, 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 6479237

 * @summary Test the format of StackTraceElement::toString and its serial form

 * @modules java.logging

 *          java.xml.bind

 * @run main SerialTest

 */

import javax.xml.bind.JAXBElement;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.OutputStream;

import java.io.UncheckedIOException;

import java.lang.reflect.Method;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.Arrays;

import java.util.logging.Logger;

public class SerialTest {

    private static final Path SER_DIR = Paths.get("sers");

    private static final String JAVA_BASE = "java.base";

    private static final String JAVA_LOGGING = "java.logging";

    private static final String JAVA_XML_BIND = "java.xml.bind";

    private static boolean isImage;

    public static void main(String... args) throws Exception {

        Files.createDirectories(SER_DIR);

        // detect if exploded image build

        Path home = Paths.get(System.getProperty("java.home"));

        isImage = Files.exists(home.resolve("lib").resolve("modules"));

        // test stack trace from built-in loaders

        try {

            Logger.getLogger(null);

        } catch (NullPointerException e) {

            Arrays.stream(e.getStackTrace())

                  .filter(ste -> ste.getClassName().startsWith("java.util.logging.") ||

                                 ste.getClassName().equals("SerialTest"))

                  .forEach(SerialTest::test);

        }

        // test stack trace with upgradeable module

        try {

            new JAXBElement(null, null, null);

        } catch (IllegalArgumentException e) {

            Arrays.stream(e.getStackTrace())

                  .filter(ste -> ste.getModuleName() != null)

                  .forEach(SerialTest::test);

        }

        // test stack trace with class loader name from other class loader

        Loader loader = new Loader("myloader");

        Class<?> cls = Class.forName("SerialTest", true, loader);

        Method method = cls.getMethod("throwException");

        StackTraceElement ste = (StackTraceElement)method.invoke(null);

        test(ste, loader);

        // verify the class loader name and in the stack trace

        if (!cls.getClassLoader().getName().equals("myloader.hacked")) {

            throw new RuntimeException("Unexpected loader name: " +

                cls.getClassLoader().getName());

        }

        if (!ste.getClassLoaderName().equals("myloader")) {

            throw new RuntimeException("Unexpected loader name: " +

                ste.getClassLoaderName());

        }

    }

    private static void test(StackTraceElement ste) {

        test(ste, null);

    }

    private static void test(StackTraceElement ste, ClassLoader loader) {

        try {

            SerialTest serialTest = new SerialTest(ste);

            StackTraceElement ste2 = serialTest.serialize().deserialize();

            System.out.println(ste2);

            // verify StackTraceElement::toString returns the same string

            if (!ste.equals(ste2) || !ste.toString().equals(ste2.toString())) {

                throw new RuntimeException(ste + " != " + ste2);

            }

            String mn = ste.getModuleName();

            if (mn != null) {

                switch (mn) {

                    case JAVA_BASE:

                    case JAVA_LOGGING:

                        checkNamedModule(ste, loader, false);

                        break;

                    case JAVA_XML_BIND:

                        // for exploded build, no version is shown

                        checkNamedModule(ste, loader, isImage);

                        break;

                    default:  // ignore

                }

            } else {

                checkUnnamedModule(ste, loader);

            }

        } catch (IOException e) {

            throw new UncheckedIOException(e);

        }

    }

    private static void checkUnnamedModule(StackTraceElement ste, ClassLoader loader) {

        String mn = ste.getModuleName();

        String s = ste.toString();

        int i = s.indexOf('/');

        if (mn != null) {

            throw new RuntimeException("expected null but got " + mn);

        }

        if (loader != null) {

            // Expect <loader>//<classname>.<method>(<src>:<ln>)

            if (i <= 0) {

                throw new RuntimeException("loader name missing: " + s);

            }

            if (!getLoaderName(loader).equals(s.substring(0, i))) {

                throw new RuntimeException("unexpected loader name: " + s);

            }

            int j = s.substring(i+1).indexOf('/');

            if (j != 0) {

                throw new RuntimeException("unexpected element for unnamed module: " + s);

            }

        }

    }

    /*

     * Loader::getName is overridden to return some other name

     */

    private static String getLoaderName(ClassLoader loader) {

        if (loader == null)

            return "";

        if (loader instanceof Loader) {

            return ((Loader) loader).name;

        } else {

            return loader.getName();

        }

    }

    private static void checkNamedModule(StackTraceElement ste,

                                         ClassLoader loader,

                                         boolean showVersion) {

        String loaderName = getLoaderName(loader);

        String mn = ste.getModuleName();

        String s = ste.toString();

        int i = s.indexOf('/');

        if (mn == null) {

            throw new RuntimeException("expected module name: " + s);

        }

        if (i <= 0) {

            throw new RuntimeException("module name missing: " + s);

        }

        // Expect <module>/<classname>.<method>(<src>:<ln>)

        if (!loaderName.isEmpty()) {

            throw new IllegalArgumentException(loaderName);

        }

        // <module>: name@version

        int j = s.indexOf('@');

        if ((showVersion && j <= 0) || (!showVersion && j >= 0)) {

            throw new RuntimeException("unexpected version: " + s);

        }

        String name = j < 0 ? s.substring(0, i) : s.substring(0, j);

        if (!name.equals(mn)) {

            throw new RuntimeException("unexpected module name: " + s);

        }

    }

    private final Path ser;

    private final StackTraceElement ste;

    SerialTest(StackTraceElement ste) throws IOException {

        this.ser = Files.createTempFile(SER_DIR, "SerialTest", ".ser");

        this.ste = ste;

    }

    private StackTraceElement deserialize() throws IOException {

        try (InputStream in = Files.newInputStream(ser);

             BufferedInputStream bis = new BufferedInputStream(in);

             ObjectInputStream ois = new ObjectInputStream(bis)) {

            return (StackTraceElement)ois.readObject();

        } catch (ClassNotFoundException e) {

            throw new RuntimeException(e);

        }

    }

    private SerialTest serialize() throws IOException {

        try (OutputStream out = Files.newOutputStream(ser);

             BufferedOutputStream bos = new BufferedOutputStream(out);

            ObjectOutputStream oos = new ObjectOutputStream(bos)) {

            oos.writeObject(ste);

        }

        return this;

    }

    public static StackTraceElement throwException() {

        try {

            Integer.parseInt(null);

        } catch (NumberFormatException e) {

            return Arrays.stream(e.getStackTrace())

                .filter(ste -> ste.getMethodName().equals("throwException"))

                .findFirst().get();

        }

        return null;

    }

    public static class Loader extends URLClassLoader {

        final String name;

        Loader(String name) throws MalformedURLException {

            super(name, new URL[] { testClassesURL() } , null);

            this.name = name;

        }

        private static URL testClassesURL() throws MalformedURLException {

            Path path = Paths.get(System.getProperty("test.classes"));

            return path.toUri().toURL();

        }

        public String getName() {

            return name + ".hacked";

        }

    }

}