--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageBasicsTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,89 @@
+/*
+ * 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
+ * @summary Tests to verify jimage basic options, i.e. --version, -h
+ * @library /test/lib
+ * @modules jdk.jlink/jdk.tools.jimage
+ * @build jdk.test.lib.Asserts
+ * @run main JImageBasicsTest
+ */
+
+import static jdk.test.lib.Asserts.assertTrue;
+
+public class JImageBasicsTest extends JImageCliTest {
+
+    public void testVersion() {
+        jimage("--version")
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.contains(System.getProperty("java.version")), "Contains java version.");
+                });
+    }
+
+    public void testFullVersion() {
+        jimage("--full-version")
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.contains(System.getProperty("java.version")), "Contains java version.");
+                });
+    }
+
+    public void testHelp() {
+        jimage("--help")
+                .assertSuccess()
+                .resultChecker(r -> verifyHelpOutput(r.output));
+    }
+
+    public void testShortHelp() {
+        jimage("-h")
+                .assertSuccess()
+                .resultChecker(r -> verifyHelpOutput(r.output));
+    }
+
+    public void testUnknownAction() {
+        jimage("unknown")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testUnknownOption() {
+        jimage("--unknown")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    private void verifyHelpOutput(String output) {
+        assertTrue(output.startsWith("Usage: jimage"), "Usage is printed.");
+        assertTrue(output.contains("extract"), "Option 'extract' is found.");
+        assertTrue(output.contains("info"), "Option 'info' is found.");
+        assertTrue(output.contains("list"), "Option 'list' is found.");
+        assertTrue(output.contains("verify"), "Option 'verify' is found.");
+    }
+
+    public static void main(String[] args) throws Throwable {
+        new JImageBasicsTest().runTests();
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageCliTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,120 @@
+/*
+ * 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.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.lang.reflect.Method;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.function.Consumer;
+import java.util.regex.Pattern;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static jdk.test.lib.Asserts.assertFalse;
+import static jdk.test.lib.Asserts.assertTrue;
+import static jdk.test.lib.Asserts.fail;
+
+/**
+ * This class is intended to be a base class for classes which are about to test
+ * command line interface of jimage.
+ */
+public class JImageCliTest {
+
+    private String bootImagePath;
+
+    public JImageCliTest() {
+        Path imagePath = Paths.get(System.getProperty("java.home"), "lib", "modules");
+        if (Files.exists(imagePath)) {
+            this.bootImagePath = imagePath.toAbsolutePath().toString();
+        }
+    }
+
+    public void assertMatches(String regex, String output) {
+        Pattern pattern = Pattern.compile(regex);
+        if (!pattern.matcher(output).find()) {
+            fail(String.format("Expected to find a string match for [%s] in output \n[\n%s\n]\n.",
+                    pattern, output));
+        }
+    }
+
+    /**
+     * Returns a path to a tested image to share it across tests. By default it returns a path to the boot image
+     * of tested JDK. This behavior can be redefined by descendants.
+     */
+    public String getImagePath() {
+        return bootImagePath;
+    }
+
+    /**
+     * Runs jimage task with the supplied arguments.
+     */
+    protected static JImageResult jimage(String... args) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        PrintStream ps = new PrintStream(baos);
+        System.out.println("jimage " + Arrays.asList(args));
+        int exitCode = jdk.tools.jimage.Main.run(args, new PrintWriter(ps));
+        return new JImageResult(exitCode, new String(baos.toByteArray(), UTF_8));
+    }
+
+    protected static class JImageResult {
+        final int exitCode;
+        final String output;
+
+        JImageResult(int exitCode, String output) {
+            this.exitCode = exitCode;
+            this.output = output;
+        }
+
+        JImageResult assertSuccess() { assertTrue(exitCode == 0, output); return this; }
+        JImageResult assertFailure() { assertFalse(exitCode == 0, output); return this; }
+
+        // a helper to ensure the error output doesn't exhibit implementation details
+        JImageResult assertShowsError() {
+            assertTrue(output.contains("Error"),
+                    String.format("Output contains error, output=[%s]\n", output));
+            assertFalse(output.contains("Exception"),
+                    String.format("Output doesn't contain a stacktrace, output=[%s]\n", output));
+            return this;
+        }
+
+        JImageResult resultChecker(Consumer<JImageResult> r) { r.accept(this); return this; }
+    }
+
+    protected final void runTests() throws Throwable {
+        if (getImagePath() != null) {
+            for (Method m : getClass().getDeclaredMethods()) {
+                if (m.getName().startsWith("test")) {
+                    System.out.printf("Invoking %s\n", m.getName());
+                    m.invoke(this);
+                }
+            }
+        } else {
+            System.out.println("This is not an image build. Skipping.");
+        }
+    }
+
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageExtractTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,181 @@
+/*
+ * 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
+ * @summary Tests to verify jimage 'extract' action
+ * @library /test/lib
+ * @modules jdk.jlink/jdk.tools.jimage
+ * @build jdk.test.lib.Asserts
+ * @run main/othervm JImageExtractTest
+ */
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileAttribute;
+import java.nio.file.attribute.PosixFilePermission;
+import java.nio.file.attribute.PosixFilePermissions;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static jdk.test.lib.Asserts.assertEquals;
+import static jdk.test.lib.Asserts.assertTrue;
+
+public class JImageExtractTest extends JImageCliTest {
+    public void testExtract() throws IOException {
+        jimage("extract", getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.isEmpty(), "Output is not expected");
+                });
+        verifyExplodedImage(Paths.get("."));
+    }
+
+    public void testExtractHelp() {
+        for (String opt : Arrays.asList("-h", "--help")) {
+            jimage("extract", "--help")
+                    .assertSuccess()
+                    .resultChecker(r -> {
+                        // extract  -  descriptive text
+                        assertMatches("\\s+extract\\s+-\\s+.*", r.output);
+                    });
+        }
+    }
+
+    public void testExtractToDir() throws IOException {
+        Path tmp = Files.createTempDirectory(Paths.get("."), getClass().getName());
+        jimage("extract", "--dir", tmp.toString(), getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.isEmpty(), "Output is not expected");
+                });
+        verifyExplodedImage(tmp);
+    }
+
+    public void testExtractNoImageSpecified() {
+        jimage("extract", "")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractNotAnImage() throws IOException {
+        Path tmp = Files.createTempFile(Paths.get("."), getClass().getName(), "not_an_image");
+        jimage("extract", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractNotExistingImage() throws IOException {
+        Path tmp = Paths.get(".", "not_existing_image");
+        Files.deleteIfExists(tmp);
+        jimage("extract", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractToUnspecifiedDir() {
+        jimage("extract", "--dir", "--", getImagePath())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractToNotExistingDir() throws IOException {
+        Path tmp = Files.createTempDirectory(Paths.get("."), getClass().getName());
+        Files.delete(tmp);
+        jimage("extract", "--dir", tmp.toString(), getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.isEmpty(), "Output is not expected");
+                });
+        verifyExplodedImage(tmp);
+    }
+
+    public void testExtractFromDir() {
+        Path imagePath = Paths.get(getImagePath());
+        Path imageDirPath = imagePath.subpath(0, imagePath.getNameCount() - 1);
+        jimage("extract", imageDirPath.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractToDirBySymlink() throws IOException {
+        Path tmp = Files.createTempDirectory(Paths.get("."), getClass().getName());
+        try {
+            Path symlink = Files.createSymbolicLink(Paths.get(".", "symlink"), tmp);
+            jimage("extract", "--dir", symlink.toString(), getImagePath())
+                    .assertSuccess()
+                    .resultChecker(r -> {
+                        assertTrue(r.output.isEmpty(), "Output is not expected");
+                    });
+            verifyExplodedImage(tmp);
+        } catch (UnsupportedOperationException e) {
+            // symlinks are not supported
+            // nothing to test
+        }
+    }
+
+    public void testExtractToReadOnlyDir() throws IOException {
+        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("r-xr--r--");
+        FileAttribute<Set<PosixFilePermission>> atts = PosixFilePermissions.asFileAttribute(perms);
+        Path tmp = Files.createTempDirectory(Paths.get("."), getClass().getName(), atts);
+        jimage("extract", "--dir", tmp.toString(), getImagePath())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractToNotEmptyDir() throws IOException {
+        Path tmp = Files.createTempDirectory(Paths.get("."), getClass().getName());
+        Files.createFile(Paths.get(tmp.toString(), ".not_empty"));
+        jimage("extract", "--dir", tmp.toString(), getImagePath())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testExtractToFile() throws IOException {
+        Path tmp = Files.createTempFile(Paths.get("."), getClass().getName(), "not_a_dir");
+        jimage("extract", "--dir", tmp.toString(), getImagePath())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    private void verifyExplodedImage(Path imagePath) throws IOException {
+        Set<Path> allModules = Files.walk(imagePath, 1).collect(Collectors.toSet());
+        assertTrue(allModules.stream().anyMatch(p -> "java.base".equals(p.getFileName().toString())),
+                "Exploded image contains java.base module.");
+
+        Set<Path> badModules = allModules.stream()
+                .filter(p -> !Files.exists(p.resolve("module-info.class")))
+                .collect(Collectors.toSet());
+        assertEquals(badModules, new HashSet<Path>() {{ add(imagePath); }},
+                "There are no exploded modules with missing 'module-info.class'");
+    }
+
+    public static void main(String[] args) throws Throwable {
+        new JImageExtractTest().runTests();
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageInfoTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,74 @@
+/*
+ * 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
+ * @summary Tests to verify jimage 'info' action
+ * @library /test/lib
+ * @modules jdk.jlink/jdk.tools.jimage
+ * @build jdk.test.lib.Asserts
+ * @run main JImageInfoTest
+ */
+
+import java.util.Arrays;
+
+public class JImageInfoTest extends JImageCliTest {
+    public void testInfo() {
+        jimage("info", getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertMatches("(?m)^\\s+Major Version: +[1-9]\\d*$.*", r.output);
+                    assertMatches("(?m)^\\s+Minor Version: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Flags: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Resource Count: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Table Length: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Offsets Size: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Redirects Size: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Locations Size: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Strings Size: +\\d+$.*", r.output);
+                    assertMatches("(?m)^\\s+Index Size: +\\d+$.*", r.output);
+                });
+    }
+
+    public void testInfoHelp() {
+        for (String opt : Arrays.asList("-h", "--help")) {
+            jimage("info", opt)
+                    .assertSuccess()
+                    .resultChecker(r -> {
+                        // info  -  descriptive text
+                        assertMatches("\\s+info\\s+-\\s+.*", r.output);
+                    });
+        }
+    }
+
+    public void testInfoUnknownOption() {
+        jimage("info", "--unknown")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public static void main(String[] args) throws Throwable {
+        new JImageInfoTest().runTests();
+    }
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageListTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,229 @@
+/*
+ * 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
+ * @summary Tests to verify jimage 'list' action
+ * @library /test/lib
+ * @modules jdk.jlink/jdk.tools.jimage
+ * @build jdk.test.lib.Asserts
+ * @run main JImageListTest
+ */
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static jdk.test.lib.Asserts.assertEquals;
+import static jdk.test.lib.Asserts.assertFalse;
+import static jdk.test.lib.Asserts.assertTrue;
+
+public class JImageListTest extends JImageCliTest {
+    public void testList() {
+        jimage("list", getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    String[] lines = r.output.split(System.lineSeparator());
+                    assertTrue(lines.length > 0, "Option --list has output.");
+                    assertTrue(lines[0].startsWith("jimage: " + getImagePath()),
+                            "Output should start with jimage path.");
+
+                    List<String> modules = Stream.of(lines)
+                            .filter(s -> s.startsWith("Module: "))
+                            .map(s -> s.substring(s.indexOf(':') + 1).trim())
+                            .collect(Collectors.toList());
+                    assertTrue(modules.size() > 0, "Image contains at least one module.");
+                    assertTrue(modules.indexOf("java.base") > 0, "Module java.base found.");
+                });
+    }
+
+    public void testListHelp() {
+        for (String opt : Arrays.asList("-h", "--help")) {
+            jimage("list", opt)
+                    .assertSuccess()
+                    .resultChecker(r -> {
+                        // list  -  descriptive text
+                        assertMatches("\\s+list\\s+-\\s+.*", r.output);
+                    });
+        }
+    }
+
+    public void testListVerbose() {
+        jimage("list", "--verbose", getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertMatches("Offset\\s+Size\\s+Compressed\\s+Entry", r.output);
+
+                    String[] lines = r.output.split("[" + System.lineSeparator() + "]+");
+                    assertTrue(lines.length > 0, "Option --list has output.");
+                    assertTrue(lines[0].startsWith("jimage: " + getImagePath()),
+                            "Output should start with jimage path.");
+
+                    List<String> modules = Stream.of(lines)
+                            .filter(s -> s.startsWith("Module: "))
+                            .map(s -> s.substring(s.indexOf(':') + 1).trim())
+                            .collect(Collectors.toList());
+                    assertTrue(modules.size() > 0, "Image contains at least one module.");
+                    assertTrue(modules.indexOf("java.base") > 0, "Module java.base found.");
+
+                    Set<String> entries = Stream.of(lines)
+                            .filter(s -> { return !s.startsWith("Module: ") && !s.startsWith("Offset"); })
+                            // Offset \d+  Size \d+  Compressed \d+ Entry \.*
+                            .filter(s -> !s.matches("\\s+\\d+\\s+\\d+\\s+\\d+\\s+.*"))
+                            .collect(Collectors.toSet());
+                    assertEquals(entries, new HashSet<>() {{ add("jimage: " + getImagePath()); }},
+                            "All entries should be in format: Offset Size Compressed Entry");
+                });
+    }
+
+    public void testListIncludeAllWithGlob() {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        JImageResult listAllGlob = jimage("list", "--include", "**", getImagePath()).assertSuccess();
+        assertEquals(listAllGlob.output, listAll.output, "--include ** should produce the same output");
+    }
+
+    public void testListIncludeWithGlob() {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        Set<String> expected = Stream.of(listAll.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> s.startsWith("java/util/zip"))
+                .collect(Collectors.toSet());
+
+        JImageResult listJavaUtil = jimage("list", "--include", "/java.base/java/util/zip/**", getImagePath()).assertSuccess();
+        Set<String> actual = Stream.of(listJavaUtil.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> !s.startsWith("jimage:") && !s.startsWith("Module:"))
+                .collect(Collectors.toSet());
+        assertEquals(actual, expected, "All java.util.zip classes are listed");
+    }
+
+    public void testListIncludeNoMatchWithGlob() {
+        JImageResult listNotMatching = jimage("list", "--include", "not_matching", getImagePath()).assertSuccess();
+        Set<String> entries = Stream.of(listNotMatching.output.split("["+ System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> !s.startsWith("jimage:") && !s.startsWith("Module:"))
+                .collect(Collectors.toSet());
+        assertEquals(entries, Collections.emptySet(), "No java.util classes are listed");
+    }
+
+    public void testListIncludeAllWithExplicitGlob() {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        JImageResult listAllGlob = jimage("list", "--include", "glob:**", getImagePath()).assertSuccess();
+        assertEquals(listAllGlob.output, listAll.output, "--include glob:** should produce the same output");
+    }
+
+    public void testListIncludeAllWithRegex() {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        JImageResult listAllRegex = jimage("list", "--include", "regex:.*", getImagePath()).assertSuccess();
+        assertEquals(listAllRegex.output, listAll.output, "--include regex:.* should produce the same output");
+    }
+
+    public void testListIncludeWithRegex() {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        Set<String> expected = Stream.of(listAll.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> s.startsWith("java/text/"))
+                .collect(Collectors.toSet());
+        assertFalse(expected.isEmpty(), "There should be classes from java.text package");
+
+        JImageResult listJavaText = jimage("list", "--include", "regex:/java.base/java/text/.*", getImagePath()).assertSuccess();
+        Set<String> actual = Stream.of(listJavaText.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> !s.startsWith("jimage:") && !s.startsWith("Module:"))
+                .collect(Collectors.toSet());
+
+        assertEquals(actual, expected, "All java.text classes are listed");
+    }
+
+    public void testListIncludeNoMatchWithRegex() {
+        JImageResult listNotMatching = jimage("list", "--include", "regex:not_matching",
+                getImagePath()).assertSuccess();
+        Set<String> entries = Stream.of(listNotMatching.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> !s.startsWith("jimage:") && !s.startsWith("Module:"))
+                .collect(Collectors.toSet());
+        assertEquals(entries, Collections.emptySet(), "No classes are listed");
+    }
+
+    public void testListIncludeMultiplePatterns() throws IOException {
+        JImageResult listAll = jimage("list", getImagePath()).assertSuccess();
+        Set<String> expected = Stream.of(listAll.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> s.startsWith("java/time/") || s.startsWith("java/util/zip"))
+                .collect(Collectors.toSet());
+        assertFalse(expected.isEmpty(), "There should be classes from java.time and java.io packages");
+
+        JImageResult listMatched = jimage("list", "--include", "glob:/java.base/java/time/**,regex:/java.base/java/util/zip/.*",
+                getImagePath()).assertSuccess();
+        Set<String> actual = Stream.of(listMatched.output.split("[" + System.lineSeparator() + "]+"))
+                .map(String::trim)
+                .filter(s -> !s.startsWith("jimage:") && !s.startsWith("Module:"))
+                .collect(Collectors.toSet());
+
+        assertEquals(actual, expected, "All java.time and java.util.zip classes are listed");
+    }
+
+    public void testListNoImageSpecified() {
+        jimage("list", "")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testListEmptyFile() throws IOException {
+        Path tmp = Files.createTempFile(Paths.get("."), getClass().getName(), "empty_file");
+        jimage("list", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testListNotAnImage() throws IOException {
+        Path tmp = Files.createTempFile(Paths.get("."), getClass().getName(), "not_an_image");
+        Files.write(tmp, "This is not an image".getBytes());
+        jimage("list", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testListNotExistingImage() throws IOException {
+        Path tmp = Paths.get(".", "not_existing_image");
+        Files.deleteIfExists(tmp);
+        jimage("list", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testListWithUnknownOption() {
+        jimage("list", "--unknown")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public static void main(String[] args) throws Throwable {
+        new JImageListTest().runTests();
+    }
+}
+

--- a/jdk/test/tools/jimage/JImageToolTest.java	Fri Nov 18 14:39:03 2016 +0800
+++ b/jdk/test/tools/jimage/JImageToolTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * 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
@@ -23,8 +23,8 @@
 /*
  * @test
  * @library /lib/testlibrary
- * @build jdk.testlibrary.*
- * @summary Test to see if jimage tool extracts and recreates correctly.
+ * @build jdk.testlibrary.ProcessTools
+ * @summary Test to check if jimage tool exists and is working
  * @run main/timeout=360 JImageToolTest
  */
 
@@ -42,7 +42,7 @@
 public class JImageToolTest {
     private static void jimage(String... jimageArgs) throws Exception {
         ArrayList<String> args = new ArrayList<>();
-        args.add("-ms8m");
+        args.add("-ms64m");
         args.add("jdk.tools.jimage.Main");
         args.addAll(Arrays.asList(jimageArgs));
 
@@ -61,11 +61,7 @@
 
         if (Files.exists(jimagePath) && Files.exists(modulesimagePath)) {
             String jimage = jimagePath.toAbsolutePath().toString();
-            String bootimage = modulesimagePath.toAbsolutePath().toString();
-            String extractDir = Paths.get(".", "extract").toAbsolutePath().toString();
-            jimage("list", bootimage);
-            jimage("verify", bootimage);
-            jimage("extract", "--dir", extractDir, bootimage);
+            jimage("--version");
             System.out.println("Test successful");
          } else {
             System.out.println("Test skipped, not an images build");

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/tools/jimage/JImageVerifyTest.java	Wed Nov 16 18:11:56 2016 +0300
@@ -0,0 +1,94 @@
+/*
+ * 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
+ * @summary Tests to verify jimage 'verify' action
+ * @library /test/lib
+ * @modules jdk.jlink/jdk.tools.jimage
+ * @build jdk.test.lib.Asserts
+ * @run main JImageVerifyTest
+ */
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import static jdk.test.lib.Asserts.assertTrue;
+
+public class JImageVerifyTest extends JImageCliTest {
+
+    public void testVerify() {
+        jimage("verify", getImagePath())
+                .assertSuccess()
+                .resultChecker(r -> {
+                    assertTrue(r.output.startsWith("jimage: " + getImagePath()),
+                            "Contains verified image's path");
+                });
+    }
+
+    public void testVerifyHelp() {
+        for (String opt : Arrays.asList("-h", "--help")) {
+            jimage("verify", opt)
+                    .assertSuccess()
+                    .resultChecker(r -> {
+                        // verify  -  descriptive text
+                        assertMatches("\\s+verify\\s+-\\s+.*", r.output);
+                    });
+        }
+    }
+
+    public void testVerifyImageNotSpecified() {
+        jimage("verify", "")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testVerifyNotAnImage() throws IOException {
+        Path tmp = Files.createTempFile(Paths.get("."), getClass().getName(), "not_an_image");
+        jimage("verify", tmp.toString())
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testVerifyNotExistingImage() throws IOException {
+        Path tmp = Paths.get(".", "not_existing_image");
+        Files.deleteIfExists(tmp);
+        jimage("verify", "")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public void testVerifyWithUnknownOption() {
+        jimage("verify", "--unknown")
+                .assertFailure()
+                .assertShowsError();
+    }
+
+    public static void main(String[] args) throws Throwable {
+        new JImageVerifyTest().runTests();
+    }
+
+}