/*
 * Copyright (c) 2015, 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
 * @library /lib/testlibrary
 * @modules jdk.compiler
 * @build AddReadsTest CompilerUtils JarUtils jdk.testlibrary.tasks.*
 * @run testng AddReadsTest
 * @summary Basic tests for java --add-reads
 */

import java.nio.file.Path;
import java.nio.file.Paths;

import jdk.testlibrary.tasks.JavaTask;
import jdk.testlibrary.tasks.Task;

import org.testng.annotations.BeforeTest;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import static org.testng.Assert.*;

/**
 * The tests consists of two modules: m1 and junit.
 * Code in module m1 calls into code in module junit but the module-info.java
 * does not have a 'requires'. Instead a read edge is added via the command
 * line option --add-reads.
 */

@Test
public class AddReadsTest {

    private static final String TEST_SRC = System.getProperty("test.src");

    private static final Path SRC_DIR = Paths.get(TEST_SRC, "src");
    private static final Path CLASSES_DIR = Paths.get("classes");
    private static final Path MODS_DIR = Paths.get("mods");

    private static final String M1 = "m1";
    private static final String MAIN = "p.Main";


    @BeforeTest
    public void setup() throws Exception {

        // javac -d classes src/junit/**
        assertTrue(CompilerUtils
            .compile(SRC_DIR.resolve("junit"), CLASSES_DIR));

        // javac -d mods/m1 -cp classes/ src/m1/**
        assertTrue(CompilerUtils
            .compile(SRC_DIR.resolve("m1"),
                    MODS_DIR.resolve("m1"),
                    "-cp", CLASSES_DIR.toString(),
                    "--add-reads", "m1=ALL-UNNAMED"));

        // jar cf mods/junit.jar -C classes .
        JarUtils.createJarFile(MODS_DIR.resolve("junit.jar"), CLASSES_DIR);

    }

    /**
     * Run with junit as a module on the module path.
     */
    public void testJUnitOnModulePath() throws Exception {
        // java --module-path mods --add-modules junit --add-reads m1=junit -m ..
        new JavaTask()
            .modulePath(MODS_DIR)
            .addModules("junit")
            .addReads("m1=junit")
            .module(M1, MAIN)
            .run();
    }


    /**
     * Exercise --add-reads m1=ALL-UNNAMED by running with junit on the
     * class path.
     */
    public void testJUnitOnClassPath() throws Exception {
        // java --module-path mods -cp mods/junit.jar --add-reads m1=ALL-UNNAMED -m ..
        new JavaTask()
            .modulePath(MODS_DIR)
            .classPath(MODS_DIR.resolve("junit.jar"))
            .addReads("m1=ALL-UNNAMED")
            .module(M1, MAIN)
            .run();
    }


    /**
     * Run with junit as a module on the module path but without --add-reads.
     */
    public void testJUnitOnModulePathMissingAddReads() throws Exception {
        // java --module-path mods --add-modules junit --module ..
        new JavaTask()
            .modulePath(MODS_DIR)
            .addModules("junit")
            .module(M1, MAIN)
            .run(Task.Expect.FAIL)
            .shouldContain(Task.OutputKind.STDERR, "IllegalAccessError");
    }


    /**
     * Run with junit on the class path but without --add-reads.
     */
    public void testJUnitOnClassPathMissingAddReads() throws Exception {
        // java --module-path mods -cp mods/junit.jar -m ..
        new JavaTask()
            .modulePath(MODS_DIR)
            .classPath(MODS_DIR.resolve("junit.jar"))
            .module(M1, MAIN)
            .run(Task.Expect.FAIL)
            .shouldContain(Task.OutputKind.STDERR, "IllegalAccessError");
    }


    /**
     * Exercise --add-reads with a more than one source module.
     */
    public void testJUnitWithMultiValueOption() throws Exception {
        new JavaTask()
            .modulePath(MODS_DIR)
            .addModules("java.xml", "junit")
            .addReads("m1=java.xml,junit")
            .module(M1, MAIN)
            .run();
    }


    /**
     * Exercise --add-reads where the target module is specified more than once
     */
    public void testWithTargetSpecifiedManyTimes() throws Exception {
        new JavaTask()
            .modulePath(MODS_DIR)
            .addModules("java.xml", "junit")
            .addReads("m1=java.xml", "m1=junit")
            .module(M1, MAIN)
            .run(Task.Expect.FAIL)
            .shouldContain(Task.OutputKind.STDOUT, "specified more than once");
    }


    /**
     * Exercise --add-reads with bad values
     */
    @Test(dataProvider = "badvalues")
    public void testWithBadValue(String value, String ignore) throws Exception {
        //  --add-exports $VALUE -version
       new JavaTask()
            .addReads(value)
            .vmOptions("-version")
            .run(Task.Expect.FAIL);
    }

    @DataProvider(name = "badvalues")
    public Object[][] badValues() {
        return new Object[][]{

            { "java.base",                  null }, // missing source
            { "java.monkey=java.base",      null }, // unknown module
            { "java.base=sun.monkey",       null }, // unknown source

        };
    }
}