Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/Java/Openjdk/test/jdk/java/lang/ClassLoader/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 8 kB

Quelle GetSystemPackage.java Sprache: JAVA

/*
* Copyright (c) 2014, 2018, 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 8060130
* @library /test/lib
* @build package2.Class2 GetSystemPackage
* @summary Test if getSystemPackage() return consistent values for cases
*          where a manifest is provided or not and ensure only jars on
*          bootclasspath gets resolved via Package.getSystemPackage
* @run main GetSystemPackage
*/

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import jdk.test.lib.process.ProcessTools;

public class GetSystemPackage {

    static final String testClassesDir = System.getProperty("test.classes", ".");
    static final File tmpFolder = new File(testClassesDir);
    static final String manifestTitle = "Special JAR";

    public static void main(String ... args) throws Exception {
        if (args.length == 0) {
            buildJarsAndInitiateSystemPackageTest();
            return;
        }
        switch (args[0]) {
            case "system-manifest":
                verifyPackage(true, true);
                break;
            case "system-no-manifest":
                verifyPackage(false, true);
                break;
            case "non-system-manifest":
                verifyPackage(true, false);
                break;
            case "non-system-no-manifest":
            default:
                verifyPackage(false, false);
                break;
        }
    }

    private static void buildJarsAndInitiateSystemPackageTest()
            throws Exception
    {
        Manifest m = new Manifest();
        // not setting MANIFEST_VERSION prevents META-INF/MANIFEST.MF from
        // getting written
        m.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
        m.getMainAttributes().put(Attributes.Name.SPECIFICATION_TITLE,
                                  manifestTitle);

        buildJar("manifest.jar", m);
        buildJar("no-manifest.jar", null);

        runSubProcess("System package with manifest improperly resolved.",
                "-Xbootclasspath/a:" + testClassesDir + "/manifest.jar",
                "GetSystemPackage", "system-manifest");

        runSubProcess("System package from directory improperly resolved.",
                "-Xbootclasspath/a:" + testClassesDir, "GetSystemPackage",
                "system-no-manifest");

        runSubProcess("System package with no manifest improperly resolved",
                "-Xbootclasspath/a:" + testClassesDir + "/no-manifest.jar",
                "GetSystemPackage", "system-no-manifest");

        runSubProcess("Classpath package with manifest improperly resolved",
                "-cp", testClassesDir + "/manifest.jar", "GetSystemPackage",
                "non-system-manifest");

        runSubProcess("Classpath package with no manifest improperly resolved",
                "-cp", testClassesDir + "/no-manifest.jar", "GetSystemPackage",
                "non-system-no-manifest");

    }

    private static void buildJar(String name, Manifest man) throws Exception {
        JarBuilder jar = new JarBuilder(tmpFolder, name, man);
        jar.addClassFile("package2/Class2.class",
                testClassesDir + "/package2/Class2.class");
        jar.addClassFile("GetSystemPackage.class",
                testClassesDir + "/GetSystemPackage.class");
        jar.build();
    }

    private static void runSubProcess(String messageOnError, String ... args)
            throws Exception
    {
        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(args);
        int res = pb.directory(tmpFolder).inheritIO().start().waitFor();
        if (res != 0) {
            throw new RuntimeException(messageOnError);
        }
    }

    private static void verifyPackage(boolean hasManifest,
                                      boolean isSystemPackage)
            throws Exception
    {
        Class<?> c = Class.forName("package2.Class2");
        Package pkg = c.getPackage();
        if (pkg == null || pkg != Package.getPackage("package2") ||
                !"package2".equals(pkg.getName())) {
            fail("package2 not found via Package.getPackage()");
        }

        String specificationTitle = pkg.getSpecificationTitle();
        if (!"package2".equals(pkg.getName())) {
            fail("Invalid package for Class2");
        }

        if (hasManifest && (specificationTitle == null
                || !manifestTitle.equals(specificationTitle))) {
            fail("Invalid manifest for package " + pkg.getName());
        }
        if (!hasManifest && specificationTitle != null) {
            fail("Invalid manifest for package " + pkg.getName() + ": was " +
                    specificationTitle + " expected: null");
        }

        ClassLoader ld = c.getClassLoader();
        Package systemPkg = ld != null ? null : Package.getPackage("package2");

        if (findPackage("java.lang") == null) {
            fail("java.lang not found via Package.getPackages()");
        }
        Package foundPackage = findPackage("package2");
        if (isSystemPackage) {
            if (systemPkg == null) {
                fail("System package could not be found via getSystemPackage");
            }
            if (foundPackage != systemPkg || systemPkg != pkg) {
                fail("Inconsistent package found via Package.getPackages()");
            }
        } else {
            if (systemPkg != null) {
                fail("Non-system package could be found via getSystemPackage");
            }
            if (foundPackage == null) {
                fail("Non-system package not found via Package.getPackages()");
            }
        }
    }

    private static Package findPackage(String name) {
        Package[] packages = Package.getPackages();
        for (Package p : packages) {
            if (p.getName().equals(name)) {
                return p;
            }
        }
        return null;
    }

    private static void fail(String message) {
        throw new RuntimeException(message);
    }
}

/*
* Helper class for building jar files
*/
class JarBuilder {

    private JarOutputStream os;

    public JarBuilder(File tmpFolder, String jarName, Manifest manifest)
            throws FileNotFoundException, IOException
    {
        File jarFile = new File(tmpFolder, jarName);
        if (manifest != null) {
            this.os = new JarOutputStream(new FileOutputStream(jarFile),
                                          manifest);
        } else {
            this.os = new JarOutputStream(new FileOutputStream(jarFile));
        }
    }

    public void addClassFile(String pathFromRoot, String file)
            throws IOException
    {
        byte[] buf = new byte[1024];
        try (FileInputStream in = new FileInputStream(file)) {
            JarEntry entry = new JarEntry(pathFromRoot);
            os.putNextEntry(entry);
            int len;
            while ((len = in.read(buf)) > 0) {
                os.write(buf, 0, len);
            }
            os.closeEntry();
        }
    }

    public void build() throws IOException {
        os.close();
    }
}

quality87%

¤ Dauer der Verarbeitung: 0.33 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.