diff --git a/make/conf/docs-modules.conf b/make/conf/docs-modules.conf
index 09b26eae9a1..e009deb85b3 100644
--- a/make/conf/docs-modules.conf
+++ b/make/conf/docs-modules.conf
@@ -42,6 +42,7 @@ DOCS_MODULES= \
     jdk.hotspot.agent \
     jdk.httpserver \
     jdk.jpackage \
+    jdk.incubator.concurrent \
     jdk.incubator.vector \
     jdk.jartool \
     jdk.javadoc \
diff --git a/make/conf/module-loader-map.conf b/make/conf/module-loader-map.conf
index f3e38bf9c28..186fd2b906e 100644
--- a/make/conf/module-loader-map.conf
+++ b/make/conf/module-loader-map.conf
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2014, 2021, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2014, 2022, 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
@@ -43,6 +43,7 @@ BOOT_MODULES= \
     java.rmi \
     java.security.sasl \
     java.xml \
+    jdk.incubator.concurrent \
     jdk.incubator.vector \
     jdk.internal.vm.ci \
     jdk.jfr \
diff --git a/src/demo/share/java2d/J2DBench/src/j2dbench/Result.java b/src/demo/share/java2d/J2DBench/src/j2dbench/Result.java
index e73e97f3b5e..1c34b901548 100644
--- a/src/demo/share/java2d/J2DBench/src/j2dbench/Result.java
+++ b/src/demo/share/java2d/J2DBench/src/j2dbench/Result.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2022, Oracle and/or its affiliates. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -40,11 +40,11 @@
 
 package j2dbench;
 
-import java.util.Vector;
-import java.util.Hashtable;
-import java.util.Enumeration;
 import java.io.PrintWriter;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Vector;
 
 public class Result {
     public static final int RATE_UNKNOWN    = 0;
@@ -243,7 +243,7 @@ public static int parseUnit(String c) {
     int repsPerRun;
     int unitsPerRep;
     Vector times;
-    Hashtable modifiers;
+    LinkedHashMap modifiers;
     Throwable error;
 
     public Result(Test test) {
@@ -277,7 +277,7 @@ public void setError(Throwable t) {
         this.error = t;
     }
 
-    public void setModifiers(Hashtable modifiers) {
+    public void setModifiers(LinkedHashMap modifiers) {
         this.modifiers = modifiers;
     }
 
@@ -297,7 +297,7 @@ public long getUnitsPerRun() {
         return ((long) getRepsPerRun()) * ((long) getUnitsPerRep());
     }
 
-    public Hashtable getModifiers() {
+    public LinkedHashMap getModifiers() {
         return modifiers;
     }
 
@@ -423,11 +423,11 @@ public void summarize() {
             System.out.println(test+" averaged "+getAverageString());
         }
         if (true) {
-            Enumeration enum_ = modifiers.keys();
+            Iterator iter_ = modifiers.keySet().iterator();
             System.out.print("    with");
             String sep = " ";
-            while (enum_.hasMoreElements()) {
-                Modifier mod = (Modifier) enum_.nextElement();
+            while (iter_.hasNext()) {
+                Modifier mod = (Modifier) iter_.next();
                 Object v = modifiers.get(mod);
                 System.out.print(sep);
                 System.out.print(mod.getAbbreviatedModifierDescription(v));
@@ -442,9 +442,9 @@ public void write(PrintWriter pw) {
                    "num-reps=\""+getRepsPerRun()+"\" "+
                    "num-units=\""+getUnitsPerRep()+"\" "+
                    "name=\""+test.getTreeName()+"\">");
-        Enumeration enum_ = modifiers.keys();
-        while (enum_.hasMoreElements()) {
-            Modifier mod = (Modifier) enum_.nextElement();
+        Iterator iter_ = modifiers.keySet().iterator();
+        while (iter_.hasNext()) {
+            Modifier mod = (Modifier) iter_.next();
             Object v = modifiers.get(mod);
             String val = mod.getModifierValueName(v);
             pw.println("    <option "+
diff --git a/src/demo/share/java2d/J2DBench/src/j2dbench/TestEnvironment.java b/src/demo/share/java2d/J2DBench/src/j2dbench/TestEnvironment.java
index ba354a06575..2b748bf0be2 100644
--- a/src/demo/share/java2d/J2DBench/src/j2dbench/TestEnvironment.java
+++ b/src/demo/share/java2d/J2DBench/src/j2dbench/TestEnvironment.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 2022, Oracle and/or its affiliates. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -40,15 +40,15 @@
 
 package j2dbench;
 
+import java.awt.AlphaComposite;
 import java.awt.Canvas;
-import java.awt.Image;
+import java.awt.Color;
+import java.awt.Dimension;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.Dimension;
-import java.awt.AlphaComposite;
-import java.awt.Color;
+import java.awt.Image;
 import java.awt.Toolkit;
-import java.util.Hashtable;
+import java.util.LinkedHashMap;
 
 import j2dbench.tests.GraphicsTests;
 
@@ -105,12 +105,12 @@ public void runAllTests() {
     Image srcImage;
     boolean stopped;
     ResultSet results;
-    Hashtable modifiers;
+    LinkedHashMap modifiers;
     Timer timer;
 
     public TestEnvironment() {
         results = new ResultSet();
-        modifiers = new Hashtable();
+        modifiers = new LinkedHashMap();
         timer = Timer.getImpl();
     }
 
@@ -246,8 +246,8 @@ public void removeModifier(Modifier o) {
         modifiers.remove(o);
     }
 
-    public Hashtable getModifiers() {
-        return (Hashtable) modifiers.clone();
+    public LinkedHashMap getModifiers() {
+        return (LinkedHashMap) modifiers.clone();
     }
 
     public void record(Result result) {
diff --git a/src/java.base/share/classes/java/lang/Double.java b/src/java.base/share/classes/java/lang/Double.java
index d733a71b56f..f0e903ddd15 100644
--- a/src/java.base/share/classes/java/lang/Double.java
+++ b/src/java.base/share/classes/java/lang/Double.java
@@ -640,7 +640,7 @@ public static String toHexString(double d) {
      * a {@code NumberFormatException} be thrown, the regular
      * expression below can be used to screen the input string:
      *
-     * <pre>{@code
+     * {@snippet lang="java" :
      *  final String Digits     = "(\\p{Digit}+)";
      *  final String HexDigits  = "(\\p{XDigit}+)";
      *  // an exponent is 'e' or 'E' followed by an optionally
@@ -679,13 +679,14 @@ public static String toHexString(double d) {
      *        ")[pP][+-]?" + Digits + "))" +
      *       "[fFdD]?))" +
      *       "[\\x00-\\x20]*");// Optional trailing "whitespace"
-     *
+     *  // @link region substring="Pattern.matches" target ="java.util.regex.Pattern#matches"
      *  if (Pattern.matches(fpRegex, myString))
      *      Double.valueOf(myString); // Will not throw NumberFormatException
+     * // @end
      *  else {
      *      // Perform suitable alternative action
      *  }
-     * }</pre>
+     * }
      *
      * @param      s   the string to be parsed.
      * @return     a {@code Double} object holding the value
@@ -1099,13 +1100,13 @@ public static long doubleToLongBits(double value) {
      * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three
      * values that can be computed from the argument:
      *
-     * <blockquote><pre>{@code
+     * {@snippet lang="java" :
      * int s = ((bits >> 63) == 0) ? 1 : -1;
      * int e = (int)((bits >> 52) & 0x7ffL);
      * long m = (e == 0) ?
      *                 (bits & 0xfffffffffffffL) << 1 :
      *                 (bits & 0xfffffffffffffL) | 0x10000000000000L;
-     * }</pre></blockquote>
+     * }
      *
      * Then the floating-point result equals the value of the mathematical
      * expression <i>s</i>&middot;<i>m</i>&middot;2<sup><i>e</i>-1075</sup>.
diff --git a/src/java.base/share/classes/java/lang/Float.java b/src/java.base/share/classes/java/lang/Float.java
index ca6f2b1d5e7..483cffa3c8a 100644
--- a/src/java.base/share/classes/java/lang/Float.java
+++ b/src/java.base/share/classes/java/lang/Float.java
@@ -922,13 +922,13 @@ public static int floatToIntBits(float value) {
      * <p>In all other cases, let <i>s</i>, <i>e</i>, and <i>m</i> be three
      * values that can be computed from the argument:
      *
-     * <blockquote><pre>{@code
+     * {@snippet lang="java" :
      * int s = ((bits >> 31) == 0) ? 1 : -1;
      * int e = ((bits >> 23) & 0xff);
      * int m = (e == 0) ?
      *                 (bits & 0x7fffff) << 1 :
      *                 (bits & 0x7fffff) | 0x800000;
-     * }</pre></blockquote>
+     * }
      *
      * Then the floating-point result equals the value of the mathematical
      * expression <i>s</i>&middot;<i>m</i>&middot;2<sup><i>e</i>-150</sup>.
diff --git a/src/java.base/share/classes/java/lang/Integer.java b/src/java.base/share/classes/java/lang/Integer.java
index 13e69da6bb4..2d20b5a79d3 100644
--- a/src/java.base/share/classes/java/lang/Integer.java
+++ b/src/java.base/share/classes/java/lang/Integer.java
@@ -1839,7 +1839,7 @@ public static int reverse(int i) {
      * @see #expand
      * @since 19
      */
-    // @IntrinsicCandidate
+    @IntrinsicCandidate
     public static int compress(int i, int mask) {
         // See Hacker's Delight (2nd ed) section 7.4 Compress, or Generalized Extract
 
@@ -1927,7 +1927,7 @@ public static int compress(int i, int mask) {
      * @see #compress
      * @since 19
      */
-    // @IntrinsicCandidate
+    @IntrinsicCandidate
     public static int expand(int i, int mask) {
         // Save original mask
         int originalMask = mask;
diff --git a/src/java.base/share/classes/java/lang/Long.java b/src/java.base/share/classes/java/lang/Long.java
index 5e44cf5c112..477b414ec94 100644
--- a/src/java.base/share/classes/java/lang/Long.java
+++ b/src/java.base/share/classes/java/lang/Long.java
@@ -1978,7 +1978,7 @@ public static long reverse(long i) {
      * @see #expand
      * @since 19
      */
-    // @IntrinsicCandidate
+    @IntrinsicCandidate
     public static long compress(long i, long mask) {
         // See Hacker's Delight (2nd ed) section 7.4 Compress, or Generalized Extract
 
@@ -2066,7 +2066,7 @@ public static long compress(long i, long mask) {
      * @see #compress
      * @since 19
      */
-    // @IntrinsicCandidate
+    @IntrinsicCandidate
     public static long expand(long i, long mask) {
         // Save original mask
         long originalMask = mask;
diff --git a/src/java.base/share/classes/module-info.java b/src/java.base/share/classes/module-info.java
index 0dc3666ae4e..e280defabe0 100644
--- a/src/java.base/share/classes/module-info.java
+++ b/src/java.base/share/classes/module-info.java
@@ -202,6 +202,7 @@
         jdk.charsets,
         jdk.compiler,
         jdk.crypto.cryptoki,
+        jdk.incubator.concurrent,
         jdk.incubator.vector,
         jdk.jfr,
         jdk.jshell,
diff --git a/src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.m b/src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.m
index 360baab2b9a..5e1d6ba0cb1 100644
--- a/src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.m
+++ b/src/java.desktop/macosx/native/libawt_lwawt/font/AWTFont.m
@@ -379,6 +379,9 @@ static OSStatus CreateFSRef(FSRef *myFSRefPtr, NSString *inPath)
     CTFontRef ctfont = (CTFontRef)nsFont;
     CFArrayRef tagsArray =
         CTFontCopyAvailableTables(ctfont, kCTFontTableOptionNoOptions);
+    if (tagsArray == NULL) {
+        return NULL;
+    }
     CFIndex numTags = CFArrayGetCount(tagsArray);
     for (i=0; i<numTags; i++) {
         if (tag ==
diff --git a/src/java.desktop/windows/classes/sun/awt/windows/WClipboard.java b/src/java.desktop/windows/classes/sun/awt/windows/WClipboard.java
index 3e82560a5cf..e16b1805295 100644
--- a/src/java.desktop/windows/classes/sun/awt/windows/WClipboard.java
+++ b/src/java.desktop/windows/classes/sun/awt/windows/WClipboard.java
@@ -83,13 +83,7 @@ protected void setContentsNative(Transferable contents) {
                         translateTransferable(contents, flavor, format);
                     publishClipboardData(format, bytes);
                 } catch (IOException e) {
-                    // Fix 4696186: don't print exception if data with
-                    // javaJVMLocalObjectMimeType failed to serialize.
-                    // May remove this if-check when 5078787 is fixed.
-                    if (!(flavor.isMimeTypeEqual(DataFlavor.javaJVMLocalObjectMimeType) &&
-                          e instanceof java.io.NotSerializableException)) {
-                        e.printStackTrace();
-                    }
+                    // Cannot be translated in this format, skip
                 }
             }
         } finally {
diff --git a/src/java.naming/share/classes/com/sun/jndi/ldap/LdapClient.java b/src/java.naming/share/classes/com/sun/jndi/ldap/LdapClient.java
index 68c54462e7e..24950ae6e0f 100644
--- a/src/java.naming/share/classes/com/sun/jndi/ldap/LdapClient.java
+++ b/src/java.naming/share/classes/com/sun/jndi/ldap/LdapClient.java
@@ -26,6 +26,7 @@
 package com.sun.jndi.ldap;
 
 import java.io.*;
+import java.util.ArrayList;
 import java.util.Locale;
 import java.util.Vector;
 import java.util.Hashtable;
@@ -1577,15 +1578,15 @@ void processUnsolicited(BerDecoder ber) {
 
 
     private void notifyUnsolicited(Object e) {
-        Vector<LdapCtx> unsolicitedCopy;
+        ArrayList<LdapCtx> unsolicitedCopy;
         synchronized (unsolicited) {
-            unsolicitedCopy = new Vector<>(unsolicited);
+            unsolicitedCopy = new ArrayList<>(unsolicited);
             if (e instanceof NamingException) {
                 unsolicited.setSize(0);  // no more listeners after exception
             }
         }
         for (int i = 0; i < unsolicitedCopy.size(); i++) {
-            unsolicitedCopy.elementAt(i).fireUnsolicited(e);
+            unsolicitedCopy.get(i).fireUnsolicited(e);
         }
     }
 
diff --git a/src/java.prefs/windows/classes/java/util/prefs/WindowsPreferences.java b/src/java.prefs/windows/classes/java/util/prefs/WindowsPreferences.java
index f2a0f7eff6e..df1f29c9c13 100644
--- a/src/java.prefs/windows/classes/java/util/prefs/WindowsPreferences.java
+++ b/src/java.prefs/windows/classes/java/util/prefs/WindowsPreferences.java
@@ -498,9 +498,9 @@ private byte[] windowsAbsolutePath() {
      * given security mask.
      * @param securityMask Windows security mask.
      * @return Windows registry key's handle.
-     * @see #openKey(byte[], int)
-     * @see #openKey(int, byte[], int)
-     * @see #closeKey(int)
+     * @see #openKey(byte[], int, int)
+     * @see #openKey(long, byte[], int, int)
+     * @see #closeKey(long)
      */
     private long openKey(int securityMask) {
         return openKey(securityMask, securityMask);
@@ -512,9 +512,9 @@ private long openKey(int securityMask) {
      * @param mask1 Preferred Windows security mask.
      * @param mask2 Alternate Windows security mask.
      * @return Windows registry key's handle.
-     * @see #openKey(byte[], int)
-     * @see #openKey(int, byte[], int)
-     * @see #closeKey(int)
+     * @see #openKey(byte[], int, int)
+     * @see #openKey(long, byte[], int, int)
+     * @see #closeKey(long)
      */
     private long openKey(int mask1, int mask2) {
         return openKey(windowsAbsolutePath(), mask1,  mask2);
@@ -529,8 +529,8 @@ private long openKey(int mask1, int mask2) {
      * @param mask2 Alternate Windows security mask.
      * @return Windows registry key's handle.
      * @see #openKey(int)
-     * @see #openKey(int, byte[],int)
-     * @see #closeKey(int)
+     * @see #openKey(long, byte[], int, int)
+     * @see #closeKey(long)
      */
     private long openKey(byte[] windowsAbsolutePath, int mask1, int mask2) {
         /*  Check if key's path is short enough be opened at once
@@ -568,15 +568,15 @@ private long openKey(byte[] windowsAbsolutePath, int mask1, int mask2) {
      /**
      * Opens Windows registry key at a given relative path
      * with respect to a given Windows registry key.
-     * @param windowsAbsolutePath Windows relative path of the
+     * @param windowsRelativePath Windows relative path of the
      *        key as a byte-encoded string.
      * @param nativeHandle handle to the base Windows key.
      * @param mask1 Preferred Windows security mask.
      * @param mask2 Alternate Windows security mask.
      * @return Windows registry key's handle.
      * @see #openKey(int)
-     * @see #openKey(byte[],int)
-     * @see #closeKey(int)
+     * @see #openKey(byte[], int, int)
+     * @see #closeKey(long)
      */
     private long openKey(long nativeHandle, byte[] windowsRelativePath,
                          int mask1, int mask2) {
@@ -630,10 +630,10 @@ private long openKey(long nativeHandle, byte[] windowsRelativePath,
      /**
      * Closes Windows registry key.
      * Logs a warning if Windows registry is unavailable.
-     * @param key's Windows registry handle.
+     * @param nativeHandle Windows registry handle.
      * @see #openKey(int)
-     * @see #openKey(byte[],int)
-     * @see #openKey(int, byte[],int)
+     * @see #openKey(byte[], int, int)
+     * @see #openKey(long, byte[], int, int)
     */
     private void closeKey(long nativeHandle) {
         int result = WindowsRegCloseKey(nativeHandle);
@@ -807,7 +807,6 @@ protected String[] childrenNamesSpi() throws BackingStoreException {
             closeKey(nativeHandle);
             return new String[0];
         }
-        String[] subkeys = new String[subKeysNumber];
         String[] children = new String[subKeysNumber];
         // Get children
         for (int i = 0; i < subKeysNumber; i++) {
@@ -870,7 +869,7 @@ public void flush() throws BackingStoreException{
     /**
      * Implements {@code Preferences} {@code sync()} method.
      * Flushes Windows registry changes to disk. Equivalent to flush().
-     * @see flush()
+     * @see #flush()
      */
     public void sync() throws BackingStoreException{
         if (isRemoved())
@@ -929,8 +928,7 @@ public void removeNodeSpi() throws BackingStoreException {
     private static String toJavaName(byte[] windowsNameArray) {
         String windowsName = byteArrayToString(windowsNameArray);
         // check if Alt64
-        if ((windowsName.length() > 1) &&
-                (windowsName.substring(0, 2).equals("/!"))) {
+        if (windowsName.startsWith("/!")) {
             return toJavaAlt64Name(windowsName);
         }
         StringBuilder javaName = new StringBuilder();
diff --git a/src/jdk.compiler/share/classes/com/sun/source/tree/Tree.java b/src/jdk.compiler/share/classes/com/sun/source/tree/Tree.java
index 6dd7bb64579..c4b71dc015c 100644
--- a/src/jdk.compiler/share/classes/com/sun/source/tree/Tree.java
+++ b/src/jdk.compiler/share/classes/com/sun/source/tree/Tree.java
@@ -613,13 +613,13 @@ public enum Kind {
 
         /**
          * Used for instances of {@link WildcardTree} representing
-         * an extends bounded wildcard type argument.
+         * an upper-bounded wildcard type argument.
          */
         EXTENDS_WILDCARD(WildcardTree.class),
 
         /**
          * Used for instances of {@link WildcardTree} representing
-         * a super bounded wildcard type argument.
+         * a lower-bounded wildcard type argument.
          */
         SUPER_WILDCARD(WildcardTree.class),
 
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/AnnoConstruct.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/AnnoConstruct.java
index 2208594b280..3557af4ac7a 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/AnnoConstruct.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/AnnoConstruct.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2022, 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
@@ -40,7 +40,7 @@
 import com.sun.tools.javac.util.ListBuffer;
 
 /**
- * Common super type for annotated constructs such as Types and Symbols.
+ * Common supertype for annotated constructs such as Types and Symbols.
  *
  * This class should *not* contain any fields since it would have a significant
  * impact on the javac memory footprint.
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java
index a8621853618..386f9eb0239 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Flags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2022, 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
@@ -179,7 +179,7 @@ public static EnumSet<Flag> asFlagSet(long flags) {
     public static final int ANONCONSTR   = 1<<29; //non-class members
 
     /**
-     * Flag to indicate the super classes of this ClassSymbol has been attributed.
+     * Flag to indicate the superclasses of this ClassSymbol has been attributed.
      */
     public static final int SUPER_OWNER_ATTRIBUTED = 1<<29; //ClassSymbols
 
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotations.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotations.java
index ae80d86625e..f9e297fa8e1 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotations.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/TypeAnnotations.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 2022, 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
@@ -1362,7 +1362,7 @@ public void visitNewClass(JCNewClass tree) {
             scan(tree.typeargs);
             if (tree.def == null) {
                 scan(tree.clazz);
-            } // else super type will already have been scanned in the context of the anonymous class.
+            } // else supertype will already have been scanned in the context of the anonymous class.
             scan(tree.args);
 
             // The class body will already be scanned.
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java
index f0b85ec2631..a6f7ca9778d 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/code/Types.java
@@ -2524,7 +2524,7 @@ public Type supertype(Type t) {
 
             public Type visitType(Type t, Void ignored) {
                 // A note on wildcards: there is no good way to
-                // determine a supertype for a super bounded wildcard.
+                // determine a supertype for a lower-bounded wildcard.
                 return Type.noType;
             }
 
@@ -2786,17 +2786,17 @@ public Type visitErrorType(ErrorType t, Void ignored) {
         };
     // </editor-fold>
 
-    // <editor-fold defaultstate="collapsed" desc="sub signature / override equivalence">
+    // <editor-fold defaultstate="collapsed" desc="subsignature / override equivalence">
     /**
-     * Returns true iff the first signature is a <em>sub
-     * signature</em> of the other.  This is <b>not</b> an equivalence
+     * Returns true iff the first signature is a <em>subsignature</em>
+     * of the other.  This is <b>not</b> an equivalence
      * relation.
      *
      * @jls 8.4.2 Method Signature
      * @see #overrideEquivalent(Type t, Type s)
      * @param t first signature (possibly raw).
      * @param s second signature (could be subjected to erasure).
-     * @return true if t is a sub signature of s.
+     * @return true if t is a subsignature of s.
      */
     public boolean isSubSignature(Type t, Type s) {
         return isSubSignature(t, s, true);
@@ -2817,7 +2817,7 @@ public boolean isSubSignature(Type t, Type s, boolean strict) {
      * erasure).
      * @param s a signature (possible raw, could be subjected to
      * erasure).
-     * @return true if either argument is a sub signature of the other.
+     * @return true if either argument is a subsignature of the other.
      */
     public boolean overrideEquivalent(Type t, Type s) {
         return hasSameArgs(t, s) ||
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
index 81fa717da85..262ad9433c2 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java
@@ -4555,7 +4555,7 @@ private Symbol selectSym(JCFieldAccess tree,
             case TYPEVAR:
                 // Normally, site.getUpperBound() shouldn't be null.
                 // It should only happen during memberEnter/attribBase
-                // when determining the super type which *must* be
+                // when determining the supertype which *must* be
                 // done before attributing the type variables.  In
                 // other words, we are seeing this illegal program:
                 // class B<T> extends A<T.foo> {}
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
index 16386fe804d..9ac8da265df 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Check.java
@@ -4606,7 +4606,7 @@ private void checkCtorAccess(JCClassDecl tree, ClassSymbol c) {
                         return ; // Don't try to recover
                     }
                 }
-                // Non-Serializable super class
+                // Non-Serializable superclass
                 try {
                     ClassSymbol supertype = ((ClassSymbol)(((DeclaredType)superClass).asElement()));
                     for(var sym : supertype.getEnclosedElements()) {
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
index 28a5b0b14a5..21963ae8752 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java
@@ -3778,7 +3778,7 @@ Symbol resolveSelf(DiagnosticPosition pos,
                             types.asSuper(env.enclClass.type, c), env.enclClass.sym);
                 }
             }
-            //find a direct super type that is a subtype of 'c'
+            //find a direct supertype that is a subtype of 'c'
             for (Type i : types.directSupertypes(env.enclClass.type)) {
                 if (i.tsym.isSubClass(c, types) && i.tsym != c) {
                     log.error(pos,
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/NewDependencyCollector.java b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/NewDependencyCollector.java
index ccb13e3f265..916047f195a 100644
--- a/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/NewDependencyCollector.java
+++ b/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/NewDependencyCollector.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2022, 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
@@ -158,8 +158,8 @@ private Map<String, Map<String, Set<String>>> getDependencies(Context context,
             }
 
             // The completion dependency graph is not transitively closed for inheritance relations.
-            // For sjavac's purposes however, a class depends on it's super super type, so below we
-            // make sure that we include super types.
+            // For sjavac's purposes however, a class depends on its super-supertype, so below we
+            // make sure that we include supertypes.
             for (ClassSymbol cs : allSupertypes(cnode.getClassSymbol())) {
                 if (isSymbolRelevant(cp, cs)) {
                     fqDeps.add(cs.outermostClass().flatname.toString());
diff --git a/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructureViolationException.java b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructureViolationException.java
new file mode 100644
index 00000000000..01bef436176
--- /dev/null
+++ b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructureViolationException.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2021, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package jdk.incubator.concurrent;
+
+/**
+ * Thrown when a structure violation is detected.
+ *
+ * @see StructuredTaskScope#fork(Callable)
+ * @see StructuredTaskScope#close()
+ *
+ * @since 19
+ */
+public final class StructureViolationException extends RuntimeException {
+    @java.io.Serial
+    private static final long serialVersionUID = -7705327650798235468L;
+
+    /**
+     * Constructs a {@code StructureViolationException} with no detail message.
+     */
+    public StructureViolationException() {
+        super();
+    }
+
+    /**
+     * Constructs a {@code StructureViolationException} with the specified
+     * detail message.
+     *
+     * @param  message the detail message, can be null
+     */
+    public StructureViolationException(String message) {
+        super(message);
+    }
+}
diff --git a/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructuredTaskScope.java b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructuredTaskScope.java
new file mode 100644
index 00000000000..a6041ab73b7
--- /dev/null
+++ b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/StructuredTaskScope.java
@@ -0,0 +1,1189 @@
+/*
+ * Copyright (c) 2021, 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+package jdk.incubator.concurrent;
+
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Function;
+import jdk.internal.misc.PreviewFeatures;
+import jdk.internal.misc.ThreadFlock;
+
+/**
+ * A basic API for <em>structured concurrency</em>. {@code StructuredTaskScope} supports
+ * cases where a task splits into several concurrent subtasks, to be executed in their
+ * own threads, and where the subtasks must complete before the main task continues. A
+ * {@code StructuredTaskScope} can be used to ensure that the lifetime of a concurrent
+ * operation is confined by a <em>syntax block</em>, just like that of a sequential
+ * operation in structured programming.
+ *
+ * <h2>Basic usage</h2>
+ *
+ * A {@code StructuredTaskScope} is created with one of its public constructors. It defines
+ * the {@link #fork(Callable) fork} method to start a thread to execute a task, the {@link
+ * #join() join} method to wait for all threads to finish, and the {@link #close() close}
+ * method to close the task scope. The API is intended to be used with the {@code
+ * try-with-resources} construct. The intention is that code in the <em>block</em> uses
+ * the {@code fork} method to fork threads to execute the subtasks, wait for the threads
+ * to finish with the {@code join} method, and then <em>process the results</em>.
+ * Processing of results may include handling or re-throwing of exceptions.
+ * {@snippet lang=java :
+ *     try (var scope = new StructuredTaskScope<Object>()) {
+ *
+ *         Future<Integer> future1 = scope.fork(task1);   // @highlight substring="fork"
+ *         Future<String> future2 = scope.fork(task2);    // @highlight substring="fork"
+ *
+ *         scope.join();                                  // @highlight substring="join"
+ *
+ *         ... process results/exceptions ...
+ *
+ *     } // close                                         // @highlight substring="close"
+ * }
+ * To ensure correct usage, the {@code join} and {@code close} methods may only be invoked
+ * by the <em>owner</em> (the thread that opened/created the task scope}, and the
+ * {@code close} method throws an exception after closing if the owner did not invoke the
+ * {@code join} method after forking.
+ *
+ * <p> {@code StructuredTaskScope} defines the {@link #shutdown() shutdown} method to shut
+ * down a task scope without closing it. Shutdown is useful for cases where a subtask
+ * completes with a result (or exception) and the results of other unfinished subtasks are
+ * no longer needed. If a subtask invokes {@code shutdown} while the owner is waiting in
+ * the {@code join} method then it will cause {@code join} to wakeup, all unfinished
+ * threads to be {@linkplain Thread#interrupt() interrupted} and prevents new threads
+ * from starting in the task scope.
+ *
+ * <h2>Subclasses with policies for common cases</h2>
+ *
+ * Two subclasses of {@code StructuredTaskScope} are defined to implement policy for
+ * common cases:
+ * <ol>
+ *   <li> {@link ShutdownOnSuccess ShutdownOnSuccess} captures the first result and
+ *   shuts down the task scope to interrupt unfinished threads and wakeup the owner. This
+ *   class is intended for cases where the result of any subtask will do ("invoke any")
+ *   and where there is no need to wait for results of other unfinished tasks. It defines
+ *   methods to get the first result or throw an exception if all subtasks fail.
+ *   <li> {@link ShutdownOnFailure ShutdownOnFailure} captures the first exception and
+ *   shuts down the task scope. This class is intended for cases where the results of all
+ *   subtasks are required ("invoke all"); if any subtask fails then the results of other
+ *   unfinished subtasks are no longer needed. If defines methods to throw an exception if
+ *   any of the subtasks fail.
+ * </ol>
+ *
+ * <p> The following are two examples that use the two classes. In both cases, a pair of
+ * subtasks are forked to fetch resources from two URL locations "left" and "right". The
+ * first example creates a ShutdownOnSuccess object to capture the result of the first
+ * subtask to complete normally, cancelling the other by way of shutting down the task
+ * scope. The main task waits in {@code join} until either subtask completes with a result
+ * or both subtasks fail. It invokes {@link ShutdownOnSuccess#result(Function)
+ * result(Function)} method to get the captured result. If both subtasks fail then this
+ * method throws a {@code WebApplicationException} with the exception from one of the
+ * subtasks as the cause.
+ * {@snippet lang=java :
+ *     try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
+ *
+ *         scope.fork(() -> fetch(left));
+ *         scope.fork(() -> fetch(right));
+ *
+ *         scope.join();
+ *
+ *         // @link regex="result(?=\()" target="ShutdownOnSuccess#result" :
+ *         String result = scope.result(e -> new WebApplicationException(e));
+ *
+ *         ...
+ *     }
+ * }
+ * The second example creates a ShutdownOnFailure object to capture the exception of the
+ * first subtask to fail, cancelling the other by way of shutting down the task scope. The
+ * main task waits in {@link #joinUntil(Instant)} until both subtasks complete with a
+ * result, either fails, or a deadline is reached. It invokes {@link
+ * ShutdownOnFailure#throwIfFailed(Function) throwIfFailed(Function)} to throw an exception
+ * when either subtask fails. This method is a no-op if no subtasks fail. The main task
+ * uses {@code Future}'s {@link Future#resultNow() resultNow()} method to retrieve the
+ * results.
+ *
+ * {@snippet lang=java :
+ *    Instant deadline = ...
+ *
+ *    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+ *
+ *         Future<String> future1 = scope.fork(() -> query(left));
+ *         Future<String> future2 = scope.fork(() -> query(right));
+ *
+ *         scope.joinUntil(deadline);
+ *
+ *         // @link substring="throwIfFailed" target="ShutdownOnFailure#throwIfFailed" :
+ *         scope.throwIfFailed(e -> new WebApplicationException(e));
+ *
+ *         // both subtasks completed successfully
+ *         String result = Stream.of(future1, future2)
+ *                 // @link substring="Future::resultNow" target="Future#resultNow" :
+ *                 .map(Future::resultNow)
+ *                 .collect(Collectors.joining(", ", "{ ", " }"));
+ *
+ *         ...
+ *     }
+ * }
+ *
+ * <h2>Extending StructuredTaskScope</h2>
+ *
+ * {@code StructuredTaskScope} can be extended, and the {@link #handleComplete(Future)
+ * handleComplete} overridden, to implement policies other than those implemented by
+ * {@code ShutdownOnSuccess} and {@code ShutdownOnFailure}. The method may be overridden
+ * to, for example, collect the results of subtasks that complete with a result and ignore
+ * subtasks that fail. It may collect exceptions when subtasks fail. It may invoke the
+ * {@link #shutdown() shutdown} method to shut down and cause {@link #join() join} to
+ * wakeup when some condition arises.
+ *
+ * <p> A subclass will typically define methods to make available results, state, or other
+ * outcome to code that executes after the {@code join} method. A subclass that collects
+ * results and ignores subtasks that fail may define a method that returns a collection of
+ * results. A subclass that implements a policy to shut down when a subtask fails may
+ * define a method to retrieve the exception of the first subtask to fail.
+ *
+ * <p> The following is an example of a {@code StructuredTaskScope} implementation that
+ * collects the results of subtasks that complete successfully. It defines the method
+ * <b>{@code results()}</b> to be used by the main task to retrieve the results.
+ *
+ * {@snippet lang=java :
+ *     class MyScope<T> extends StructuredTaskScope<T> {
+ *         private final Queue<T> results = new ConcurrentLinkedQueue<>();
+ *
+ *         MyScope() {
+ *             super(null, Thread.ofVirtual().factory());
+ *         }
+ *
+ *         @Override
+ *         // @link substring="handleComplete" target="handleComplete" :
+ *         protected void handleComplete(Future<T> future) {
+ *             if (future.state() == Future.State.SUCCESS) {
+ *                 T result = future.resultNow();
+ *                 results.add(result);
+ *             }
+ *         }
+ *
+ *         // Returns a stream of results from the subtasks that completed successfully
+ *         public Stream<T> results() {     // @highlight substring="results"
+ *             return results.stream();
+ *         }
+ *     }
+ *  }
+ *
+ * <h2><a id="TreeStructure">Tree structure</a></h2>
+ *
+ * StructuredTaskScopes form a tree where parent-child relations are established
+ * implicitly when opening a new task scope:
+ * <ul>
+ *   <li> A parent-child relation is established when a thread started in a task scope
+ *   opens its own task scope. A thread started in task scope "A" that opens task scope
+ *   "B" establishes a parent-child relation where task scope "A" is the parent of task
+ *   scope "B".
+ *   <li> A parent-child relation is established with nesting. If a thread opens task
+ *   scope "B", then opens task scope "C" (before it closes "B"), then the enclosing task
+ *   scope "B" is the parent of the nested task scope "C".
+ * </ul>
+ *
+ * <p> The tree structure supports confinement checks. The phrase "threads contained in
+ * the task scope" in method descriptions means threads started in the task scope or
+ * descendant scopes. {@code StructuredTaskScope} does not define APIs that exposes the
+ * tree structure at this time.
+ *
+ * <p> Unless otherwise specified, passing a {@code null} argument to a constructor
+ * or method in this class will cause a {@link NullPointerException} to be thrown.
+ *
+ * <h2>Memory consistency effects</h2>
+ *
+ * <p> Actions in the owner thread of, or a thread contained in, the task scope prior to
+ * {@linkplain #fork forking} of a {@code Callable} task
+ * <a href="../../../../java.base/java/util/concurrent/package-summary.html#MemoryVisibility">
+ * <i>happen-before</i></a> any actions taken by that task, which in turn <i>happen-before</i>
+ * the task result is retrieved via its {@code Future}, or <i>happen-before</i> any actions
+ * taken in a thread after {@linkplain #join() joining} of the task scope.
+ *
+ * @jls 17.4.5 Happens-before Order
+ *
+ * @param <T> the result type of tasks executed in the scope
+ * @since 19
+ */
+public class StructuredTaskScope<T> implements AutoCloseable {
+    private static final VarHandle FUTURES;
+    static {
+        try {
+            MethodHandles.Lookup l = MethodHandles.lookup();
+            FUTURES = l.findVarHandle(StructuredTaskScope.class, "futures", Set.class);
+        } catch (Exception e) {
+            throw new InternalError(e);
+        }
+    }
+
+    private final ThreadFactory factory;
+    private final ThreadFlock flock;
+    private final ReentrantLock shutdownLock = new ReentrantLock();
+
+    // lazily created set of Future objects with threads waiting in Future::get
+    private volatile Set<Future<?>> futures;
+
+    // set by owner when it forks, reset by owner when it joins
+    private boolean needJoin;
+
+    // states: OPEN -> SHUTDOWN -> CLOSED
+    private static final int OPEN     = 0;   // initial state
+    private static final int SHUTDOWN = 1;
+    private static final int CLOSED   = 2;
+
+    // scope state, set by owner, read by any thread
+    private volatile int state;
+
+    /**
+     * Creates a structured task scope with the given name and thread factory. The task
+     * scope is optionally named for the purposes of monitoring and management. The thread
+     * factory is used to {@link ThreadFactory#newThread(Runnable) create} threads when
+     * tasks are {@linkplain #fork(Callable) forked}. The task scope is owned by the
+     * current thread.
+     *
+     * @param name the name of the task scope, can be null
+     * @param factory the thread factory
+     */
+    public StructuredTaskScope(String name, ThreadFactory factory) {
+        this.factory = Objects.requireNonNull(factory, "'factory' is null");
+        this.flock = ThreadFlock.open(name);
+    }
+
+    /**
+     * Creates an unnamed structured task scope that creates virtual threads. The task
+     * scope is owned by the current thread.
+     *
+     * <p> This constructor is equivalent to invoking the 2-arg constructor with a name
+     * of {@code null} and a thread factory that creates virtual threads.
+     *
+     * @throws UnsupportedOperationException if preview features are not enabled
+     */
+    public StructuredTaskScope() {
+        PreviewFeatures.ensureEnabled();
+        this.factory = FactoryHolder.VIRTUAL_THREAD_FACTORY;
+        this.flock = ThreadFlock.open(null);
+    }
+
+    /**
+     * Throws WrongThreadException if the current thread is not the owner.
+     */
+    private void ensureOwner() {
+        if (Thread.currentThread() != flock.owner())
+            throw new WrongThreadException("Current thread not owner");
+    }
+
+    /**
+     * Throws WrongThreadException if the current thread is not the owner
+     * or a thread contained in the tree.
+     */
+    private void ensureOwnerOrContainsThread() {
+        Thread currentThread = Thread.currentThread();
+        if (currentThread != flock.owner() && !flock.containsThread(currentThread))
+            throw new WrongThreadException("Current thread not owner or thread in the tree");
+    }
+
+    /**
+     * Tests if the task scope is shutdown.
+     */
+    private boolean isShutdown() {
+        return state >= SHUTDOWN;
+    }
+
+    /**
+     * Track the given Future.
+     */
+    private void track(Future<?> future) {
+        // create the set of Futures if not already created
+        Set<Future<?>> futures = this.futures;
+        if (futures == null) {
+            futures = ConcurrentHashMap.newKeySet();
+            if (!FUTURES.compareAndSet(this, null, futures)) {
+                // lost the race
+                futures = this.futures;
+            }
+        }
+        futures.add(future);
+    }
+
+    /**
+     * Stop tracking the Future.
+     */
+    private void untrack(Future<?> future) {
+        assert futures != null;
+        futures.remove(future);
+    }
+
+    /**
+     * Invoked when a task completes before the scope is shut down.
+     *
+     * <p> The {@code handleComplete} method should be thread safe. It may be invoked by
+     * several threads concurrently.
+     *
+     * @implSpec The default implementation does nothing.
+     *
+     * @param future the completed task
+     */
+    protected void handleComplete(Future<T> future) { }
+
+    /**
+     * Starts a new thread to run the given task.
+     *
+     * <p> The new thread is created with the task scope's {@link ThreadFactory}.
+     *
+     * <p> If the task completes before the task scope is {@link #shutdown() shutdown}
+     * then the {@link #handleComplete(Future) handle} method is invoked to consume the
+     * completed task. The {@code handleComplete} method is run when the task completes
+     * with a result or exception. If the {@code Future} {@link Future#cancel(boolean)
+     * cancel} method is used the cancel a task before the task scope is shut down, then
+     * the {@code handleComplete} method is run by the thread that invokes {@code cancel}.
+     * If the task scope shuts down at or around the same time that the task completes or
+     * is cancelled then the {@code handleComplete} method may or may not be invoked.
+     *
+     * <p> If this task scope is {@linkplain #shutdown() shutdown} (or in the process
+     * of shutting down) then {@code fork} returns a {@code Future} representing a {@link
+     * Future.State#CANCELLED cancelled} task that was not run.
+     *
+     * <p> This method may only be invoked by the task scope owner or threads contained
+     * in the task scope. The {@link Future#cancel(boolean) cancel} method of the returned
+     * {@code Future} object is also restricted to the task scope owner or threads contained
+     * in the task scope. The {@code cancel} method throws {@link WrongThreadException}
+     * if invoked from another thread. All other methods on the returned {@code Future}
+     * object, such as {@link Future#get() get}, are not restricted.
+     *
+     * @param task the task to run
+     * @param <U> the result type
+     * @return a future
+     * @throws IllegalStateException if this task scope is closed
+     * @throws WrongThreadException if the current thread is not the owner or a thread
+     * contained in the task scope
+     * @throws RejectedExecutionException if the thread factory rejected creating a
+     * thread to run the task
+     */
+    public <U extends T> Future<U> fork(Callable<? extends U> task) {
+        Objects.requireNonNull(task, "'task' is null");
+
+        // create future
+        var future = new FutureImpl<U>(this, task);
+
+        boolean shutdown = (state >= SHUTDOWN);
+
+        if (!shutdown) {
+            // create thread
+            Thread thread = factory.newThread(future);
+            if (thread == null) {
+                throw new RejectedExecutionException("Rejected by thread factory");
+            }
+
+            // attempt to start the thread
+            try {
+                flock.start(thread);
+            } catch (IllegalStateException e) {
+                // shutdown or in the process of shutting down
+                shutdown = true;
+            }
+        }
+
+        if (shutdown) {
+            if (state == CLOSED) {
+                throw new IllegalStateException("Task scope is closed");
+            } else {
+                future.cancel(false);
+            }
+        }
+
+        // if owner forks then it will need to join
+        if (Thread.currentThread() == flock.owner() && !needJoin) {
+            needJoin = true;
+        }
+
+        return future;
+    }
+
+    /**
+     * Wait for all threads to finish or the task scope to shut down.
+     */
+    private void implJoin(Duration timeout)
+        throws InterruptedException, TimeoutException
+    {
+        ensureOwner();
+        needJoin = false;
+        int s = state;
+        if (s >= SHUTDOWN) {
+            if (s == CLOSED)
+                throw new IllegalStateException("Task scope is closed");
+            return;
+        }
+
+        // wait for all threads, wakeup, interrupt, or timeout
+        if (timeout != null) {
+            flock.awaitAll(timeout);
+        } else {
+            flock.awaitAll();
+        }
+    }
+
+    /**
+     * Wait for all threads to finish or the task scope to shut down. This method waits
+     * until all threads started in the task scope finish execution (of both task and
+     * {@link #handleComplete(Future) handleComplete} method), the {@link #shutdown()
+     * shutdown} method is invoked to shut down the task scope, or the current thread
+     * is {@linkplain Thread#interrupt() interrupted}.
+     *
+     * <p> This method may only be invoked by the task scope owner.
+     *
+     * @return this task scope
+     * @throws IllegalStateException if this task scope is closed
+     * @throws WrongThreadException if the current thread is not the owner
+     * @throws InterruptedException if interrupted while waiting
+     */
+    public StructuredTaskScope<T> join() throws InterruptedException {
+        try {
+            implJoin(null);
+        } catch (TimeoutException e) {
+            throw new InternalError();
+        }
+        return this;
+    }
+
+    /**
+     * Wait for all threads to finish or the task scope to shut down, up to the given
+     * deadline. This method waits until all threads started in the task scope finish
+     * execution (of both task and {@link #handleComplete(Future) handleComplete} method),
+     * the {@link #shutdown() shutdown} method is invoked to shut down the task scope,
+     * the current thread is {@linkplain Thread#interrupt() interrupted}, or the deadline
+     * is reached.
+     *
+     * <p> This method may only be invoked by the task scope owner.
+     *
+     * @param deadline the deadline
+     * @return this task scope
+     * @throws IllegalStateException if this task scope is closed
+     * @throws WrongThreadException if the current thread is not the owner
+     * @throws InterruptedException if interrupted while waiting
+     * @throws TimeoutException if the deadline is reached while waiting
+     */
+    public StructuredTaskScope<T> joinUntil(Instant deadline)
+        throws InterruptedException, TimeoutException
+    {
+        Duration timeout = Duration.between(Instant.now(), deadline);
+        implJoin(timeout);
+        return this;
+    }
+
+    /**
+     * Cancel all tracked Future objects.
+     */
+    private void cancelTrackedFutures() {
+        Set<Future<?>> futures = this.futures;
+        if (futures != null) {
+            futures.forEach(f -> f.cancel(false));
+        }
+    }
+
+    /**
+     * Interrupt all unfinished threads.
+     */
+    private void implInterruptAll() {
+        flock.threads().forEach(t -> {
+            if (t != Thread.currentThread()) {
+                t.interrupt();
+            }
+        });
+    }
+
+    @SuppressWarnings("removal")
+    private void interruptAll() {
+        if (System.getSecurityManager() == null) {
+            implInterruptAll();
+        } else {
+            PrivilegedAction<Void> pa = () -> {
+                implInterruptAll();
+                return null;
+            };
+            AccessController.doPrivileged(pa);
+        }
+    }
+
+    /**
+     * Shutdown the task scope if not already shutdown. Return true if this method
+     * shutdowns the task scope, false if already shutdown.
+     */
+    private boolean implShutdown() {
+        if (state < SHUTDOWN) {
+            shutdownLock.lock();
+            try {
+                if (state < SHUTDOWN) {
+
+                    // prevent new threads from starting
+                    flock.shutdown();
+
+                    // wakeup any threads waiting in Future::get
+                    cancelTrackedFutures();
+
+                    // interrupt all unfinished threads
+                    interruptAll();
+
+                    state = SHUTDOWN;
+                    return true;
+                }
+            } finally {
+                shutdownLock.unlock();
+            }
+        }
+        assert state >= SHUTDOWN;
+        return false;
+    }
+
+    /**
+     * Shut down the task scope without closing it. Shutting down a task scope prevents
+     * new threads from starting, interrupts all unfinished threads, and causes the
+     * {@link #join() join} method to wakeup. Shutdown is useful for cases where the
+     * results of unfinished subtasks are no longer needed.
+     *
+     * <p> More specifically, this method:
+     * <ul>
+     * <li> {@linkplain Future#cancel(boolean) Cancels} the tasks that have threads
+     * {@linkplain Future#get() waiting} on a result so that the waiting threads wakeup.
+     * <li> {@linkplain Thread#interrupt() Interrupts} all unfinished threads in the
+     * task scope (except the current thread).
+     * <li> Wakes up the owner if it is waiting in {@link #join()} or {@link
+     * #joinUntil(Instant)}. If the owner is not waiting then its next call to {@code
+     * join} or {@code joinUntil} will return immediately.
+     * </ul>
+     *
+     * <p> When this method completes then the {@code Future} objects for all tasks will
+     * be {@linkplain Future#isDone() done}, normally or abnormally. There may still
+     * be threads that have not finished because they are executing code that did not
+     * respond (or respond promptly) to thread interrupt. This method does not wait
+     * for these threads. When the owner invokes the {@link #close() close} method
+     * to close the task scope then it will wait for the remaining threads to finish.
+     *
+     * <p> This method may only be invoked by the task scope owner or threads contained
+     * in the task scope.
+     *
+     * @throws IllegalStateException if this task scope is closed
+     * @throws WrongThreadException if the current thread is not the owner or
+     * a thread contained in the task scope
+     */
+    public void shutdown() {
+        ensureOwnerOrContainsThread();
+        if (state == CLOSED)
+            throw new IllegalStateException("Task scope is closed");
+        if (implShutdown())
+            flock.wakeup();
+    }
+
+    /**
+     * Closes this task scope.
+     *
+     * <p> This method first shuts down the task scope (as if by invoking the {@link
+     * #shutdown() shutdown} method). It then waits for the threads executing any
+     * unfinished tasks to finish. If interrupted then this method will continue to
+     * wait for the threads to finish before completing with the interrupt status set.
+     *
+     * <p> This method may only be invoked by the task scope owner. If the task scope
+     * is already closed then the owner invoking this method has no effect.
+     *
+     * <p> A {@code StructuredTaskScope} is intended to be used in a <em>structured
+     * manner</em>. If this method is called to close a task scope before nested task
+     * scopes are closed then it closes the underlying construct of each nested task scope
+     * (in the reverse order that they were created in), closes this task scope, and then
+     * throws {@link StructureViolationException}.
+     * If a thread terminates without first closing task scopes that it owns then
+     * termination will cause the underlying construct of each of its open tasks scopes to
+     * be closed. Closing is performed in the reverse order that the task scopes were
+     * created in. Thread termination may therefore be delayed when the owner has to wait
+     * for threads forked in these task scopes to finish.
+     *
+     * @throws IllegalStateException thrown after closing the task scope if the owner
+     * did not invoke join after forking
+     * @throws WrongThreadException if the current thread is not the owner
+     * @throws StructureViolationException if a structure violation was detected
+     */
+    @Override
+    public void close() {
+        ensureOwner();
+        if (state == CLOSED)
+            return;
+
+        try {
+            implShutdown();
+            flock.close();
+        } finally {
+            state = CLOSED;
+        }
+
+        if (needJoin) {
+            throw new IllegalStateException("Owner did not invoke join or joinUntil after fork");
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        String name = flock.name();
+        if (name != null) {
+            sb.append(name);
+            sb.append('/');
+        }
+        sb.append(Objects.toIdentityString(this));
+        int s = state;
+        if (s == CLOSED)
+            sb.append("/closed");
+        else if (s == SHUTDOWN)
+            sb.append("/shutdown");
+        return sb.toString();
+    }
+
+    /**
+     * The Future implementation returned by the fork methods. Most methods are
+     * overridden to support cancellation when the task scope is shutdown.
+     * The blocking get methods register the Future with the task scope so that they
+     * are cancelled when the task scope shuts down.
+     */
+    private static final class FutureImpl<V> extends FutureTask<V> {
+        private final StructuredTaskScope<V> scope;
+
+        @SuppressWarnings("unchecked")
+        FutureImpl(StructuredTaskScope<? super V> scope, Callable<? extends V> task) {
+            super((Callable<V>) task);
+            this.scope = (StructuredTaskScope<V>) scope;
+        }
+
+        @Override
+        protected void done() {
+            if (!scope.isShutdown()) {
+                scope.handleComplete(this);
+            }
+        }
+
+        private void cancelIfShutdown() {
+            if (scope.isShutdown() && !super.isDone()) {
+                super.cancel(false);
+            }
+        }
+
+        @Override
+        public boolean isDone() {
+            cancelIfShutdown();
+            return super.isDone();
+        }
+
+        @Override
+        public boolean isCancelled() {
+            cancelIfShutdown();
+            return super.isCancelled();
+        }
+
+        @Override
+        public boolean cancel(boolean mayInterruptIfRunning) {
+            scope.ensureOwnerOrContainsThread();
+            cancelIfShutdown();
+            return super.cancel(mayInterruptIfRunning);
+        }
+
+        @Override
+        public V get() throws InterruptedException, ExecutionException {
+            if (super.isDone())
+                return super.get();
+            scope.track(this);
+            try {
+                cancelIfShutdown();
+                return super.get();
+            } finally {
+                scope.untrack(this);
+            }
+        }
+
+        @Override
+        public V get(long timeout, TimeUnit unit)
+                throws InterruptedException, ExecutionException, TimeoutException {
+            Objects.requireNonNull(unit);
+            if (super.isDone())
+                return super.get();
+            scope.track(this);
+            try {
+                cancelIfShutdown();
+                return super.get(timeout, unit);
+            } finally {
+                scope.untrack(this);
+            }
+        }
+
+        @Override
+        public V resultNow() {
+            cancelIfShutdown();
+            return super.resultNow();
+        }
+
+        @Override
+        public Throwable exceptionNow() {
+            cancelIfShutdown();
+            return super.exceptionNow();
+        }
+
+        @Override
+        public State state() {
+            cancelIfShutdown();
+            return super.state();
+        }
+
+        @Override
+        public String toString() {
+            cancelIfShutdown();
+            return super.toString();
+        }
+    }
+
+    /**
+     * Maps a Future.State to an int that can be compared.
+     * RUNNING < CANCELLED < FAILED < SUCCESS.
+     */
+    private static int futureStateToInt(Future.State s) {
+        return switch (s) {
+            case RUNNING   -> 0;
+            case CANCELLED -> 1;
+            case FAILED    -> 2;
+            case SUCCESS   -> 3;
+        };
+    }
+
+    // RUNNING < CANCELLED < FAILED < SUCCESS
+    private static final Comparator<Future.State> FUTURE_STATE_COMPARATOR =
+            Comparator.comparingInt(StructuredTaskScope::futureStateToInt);
+
+    /**
+     * A {@code StructuredTaskScope} that captures the result of the first subtask to
+     * complete successfully. Once captured, it invokes the {@linkplain #shutdown() shutdown}
+     * method to interrupt unfinished threads and wakeup the owner. The policy
+     * implemented by this class is intended for cases where the result of any subtask
+     * will do ("invoke any") and where the results of other unfinished subtask are no
+     * longer needed.
+     *
+     * <p> Unless otherwise specified, passing a {@code null} argument to a method
+     * in this class will cause a {@link NullPointerException} to be thrown.
+     *
+     * @param <T> the result type
+     * @since 19
+     */
+    public static final class ShutdownOnSuccess<T> extends StructuredTaskScope<T> {
+        private static final VarHandle FUTURE;
+        static {
+            try {
+                MethodHandles.Lookup l = MethodHandles.lookup();
+                FUTURE = l.findVarHandle(ShutdownOnSuccess.class, "future", Future.class);
+            } catch (Exception e) {
+                throw new InternalError(e);
+            }
+        }
+        private volatile Future<T> future;
+
+        /**
+         * Constructs a new {@code ShutdownOnSuccess} with the given name and thread factory.
+         * The task scope is optionally named for the purposes of monitoring and management.
+         * The thread factory is used to {@link ThreadFactory#newThread(Runnable) create}
+         * threads when tasks are {@linkplain #fork(Callable) forked}. The task scope is
+         * owned by the current thread.
+         *
+         * @param name the name of the task scope, can be null
+         * @param factory the thread factory
+         */
+        public ShutdownOnSuccess(String name, ThreadFactory factory) {
+            super(name, factory);
+        }
+
+        /**
+         * Constructs a new unnamed {@code ShutdownOnSuccess} that creates virtual threads.
+         *
+         * <p> This constructor is equivalent to invoking the 2-arg constructor with a
+         * name of {@code null} and a thread factory that creates virtual threads.
+         */
+        public ShutdownOnSuccess() {
+            super(null, FactoryHolder.VIRTUAL_THREAD_FACTORY);
+        }
+
+        /**
+         * Shut down the given task scope when invoked for the first time with a {@code
+         * Future} for a task that completed with a result.
+         *
+         * @param future the completed task
+         * @see #shutdown()
+         * @see Future.State#SUCCESS
+         */
+        @Override
+        protected void handleComplete(Future<T> future) {
+            Future.State state = future.state();
+            if (state == Future.State.RUNNING) {
+                throw new IllegalArgumentException("Task is not completed");
+            }
+
+            Future<T> f;
+            while (((f = this.future) == null)
+                    || FUTURE_STATE_COMPARATOR.compare(f.state(), state) < 0) {
+                if (FUTURE.compareAndSet(this, f, future)) {
+                    if (state == Future.State.SUCCESS)
+                        shutdown();
+                    break;
+                }
+            }
+        }
+
+        /**
+         * {@inheritDoc}
+         * @return this task scope
+         * @throws IllegalStateException {@inheritDoc}
+         * @throws WrongThreadException {@inheritDoc}
+         */
+        @Override
+        public ShutdownOnSuccess<T> join() throws InterruptedException {
+            super.join();
+            return this;
+        }
+
+        /**
+         * {@inheritDoc}
+         * @return this task scope
+         * @throws IllegalStateException {@inheritDoc}
+         * @throws WrongThreadException {@inheritDoc}
+         */
+        @Override
+        public ShutdownOnSuccess<T> joinUntil(Instant deadline)
+            throws InterruptedException, TimeoutException
+        {
+            super.joinUntil(deadline);
+            return this;
+        }
+
+        /**
+         * {@return the result of the first subtask that completed with a result}
+         *
+         * <p> When no subtask completed with a result but a task completed with an
+         * exception then {@code ExecutionException} is thrown with the exception as the
+         * {@linkplain Throwable#getCause() cause}. If only cancelled subtasks were
+         * notified to the {@code handleComplete} method then {@code CancellationException}
+         * is thrown.
+         *
+         * @apiNote This method is intended to be invoked by the task scope owner after it
+         * has invoked {@link #join() join} (or {@link #joinUntil(Instant) joinUntil}).
+         * A future release may add enforcement to prevent the method being called by
+         * other threads or before joining.
+         *
+         * @throws ExecutionException if no subtasks completed with a result but a subtask
+         * completed with an exception
+         * @throws CancellationException if all subtasks were cancelled
+         * @throws IllegalStateException if the handle method was not invoked with a
+         * completed subtask
+         */
+        public T result() throws ExecutionException {
+            Future<T> f = future;
+            if (f == null) {
+                throw new IllegalStateException("No completed subtasks");
+            }
+            return switch (f.state()) {
+                case SUCCESS   -> f.resultNow();
+                case FAILED    -> throw new ExecutionException(f.exceptionNow());
+                case CANCELLED -> throw new CancellationException();
+                default        -> throw new InternalError("Unexpected state: " + f);
+            };
+
+        }
+
+        /**
+         * Returns the result of the first subtask that completed with a result, otherwise
+         * throws an exception produced by the given exception supplying function.
+         *
+         * <p> When no subtask completed with a result but a subtask completed with an
+         * exception then the exception supplying function is invoked with the exception.
+         * If only cancelled subtasks were notified to the {@code handleComplete} method
+         * then the exception supplying function is invoked with a {@code CancellationException}.
+         *
+         * @apiNote This method is intended to be invoked by the task scope owner after it
+         * has invoked {@link #join() join} (or {@link #joinUntil(Instant) joinUntil}).
+         * A future release may add enforcement to prevent the method being called by
+         * other threads or before joining.
+         *
+         * @param esf the exception supplying function
+         * @param <X> type of the exception to be thrown
+         * @return the result of the first subtask that completed with a result
+         * @throws X if no subtask completed with a result
+         * @throws IllegalStateException if the handle method was not invoked with a
+         * completed subtask
+         */
+        public <X extends Throwable> T result(Function<Throwable, ? extends X> esf) throws X {
+            Objects.requireNonNull(esf);
+            Future<T> f = future;
+            if (f == null) {
+                throw new IllegalStateException("No completed subtasks");
+            }
+            Future.State state = f.state();
+            if (state == Future.State.SUCCESS) {
+                return f.resultNow();
+            } else {
+                Throwable throwable = (state == Future.State.FAILED)
+                        ? f.exceptionNow()
+                        : new CancellationException();
+                X ex = esf.apply(throwable);
+                Objects.requireNonNull(ex, "esf returned null");
+                throw ex;
+            }
+        }
+    }
+
+    /**
+     * A {@code StructuredTaskScope} that captures the exception of the first subtask to
+     * complete abnormally. Once captured, it invokes the {@linkplain #shutdown() shutdown}
+     * method to interrupt unfinished threads and wakeup the owner. The policy implemented
+     * by this class is intended for cases where the results for all subtasks are required
+     * ("invoke all"); if any subtask fails then the results of other unfinished subtasks
+     * are no longer needed.
+     *
+     * <p> Unless otherwise specified, passing a {@code null} argument to a method
+     * in this class will cause a {@link NullPointerException} to be thrown.
+     *
+     * @since 19
+     */
+    public static final class ShutdownOnFailure extends StructuredTaskScope<Object> {
+        private static final VarHandle FUTURE;
+        static {
+            try {
+                MethodHandles.Lookup l = MethodHandles.lookup();
+                FUTURE = l.findVarHandle(ShutdownOnFailure.class, "future", Future.class);
+            } catch (Exception e) {
+                throw new InternalError(e);
+            }
+        }
+        private volatile Future<Object> future;
+
+        /**
+         * Constructs a new {@code ShutdownOnFailure} with the given name and thread factory.
+         * The task scope is optionally named for the purposes of monitoring and management.
+         * The thread factory is used to {@link ThreadFactory#newThread(Runnable) create}
+         * threads when tasks are {@linkplain #fork(Callable) forked}. The task scope
+         * is owned by the current thread.
+         *
+         * @param name the name of the task scope, can be null
+         * @param factory the thread factory
+         */
+        public ShutdownOnFailure(String name, ThreadFactory factory) {
+            super(name, factory);
+        }
+
+        /**
+         * Constructs a new unnamed {@code ShutdownOnFailure} that creates virtual threads.
+         *
+         * <p> This constructor is equivalent to invoking the 2-arg constructor with a
+         * name of {@code null} and a thread factory that creates virtual threads.
+         */
+        public ShutdownOnFailure() {
+            super(null, FactoryHolder.VIRTUAL_THREAD_FACTORY);
+        }
+
+        /**
+         * Shut down the given task scope when invoked for the first time with a {@code
+         * Future} for a task that completed abnormally (exception or cancelled).
+         *
+         * @param future the completed task
+         * @see #shutdown()
+         * @see Future.State#FAILED
+         * @see Future.State#CANCELLED
+         */
+        @Override
+        protected void handleComplete(Future<Object> future) {
+            Future.State state = future.state();
+            if (state == Future.State.RUNNING) {
+                throw new IllegalArgumentException("Task is not completed");
+            } else if (state == Future.State.SUCCESS) {
+                return;
+            }
+
+            // A failed task overrides a cancelled task.
+            // The first failed or cancelled task causes the scope to shutdown.
+            Future<Object> f;
+            while (((f = this.future) == null)
+                    || FUTURE_STATE_COMPARATOR.compare(f.state(), state) < 0) {
+                if (FUTURE.compareAndSet(this, f, future)) {
+                    shutdown();
+                    break;
+                }
+            }
+        }
+
+        /**
+         * {@inheritDoc}
+         * @return this task scope
+         * @throws IllegalStateException {@inheritDoc}
+         * @throws WrongThreadException {@inheritDoc}
+         */
+        @Override
+        public ShutdownOnFailure join() throws InterruptedException {
+            super.join();
+            return this;
+        }
+
+        /**
+         * {@inheritDoc}
+         * @return this task scope
+         * @throws IllegalStateException {@inheritDoc}
+         * @throws WrongThreadException {@inheritDoc}
+         */
+        @Override
+        public ShutdownOnFailure joinUntil(Instant deadline)
+            throws InterruptedException, TimeoutException
+        {
+            super.joinUntil(deadline);
+            return this;
+        }
+
+        /**
+         * Returns the exception for the first subtask that completed with an exception.
+         * If no subtask completed with an exception but cancelled subtasks were notified
+         * to the {@code handleComplete} method then a {@code CancellationException}
+         * is returned. If no subtasks completed abnormally then an empty {@code Optional}
+         * is returned.
+         *
+         * @apiNote This method is intended to be invoked by the task scope owner after it
+         * has invoked {@link #join() join} (or {@link #joinUntil(Instant) joinUntil}).
+         * A future release may add enforcement to prevent the method being called by
+         * other threads or before joining.
+         *
+         * @return the exception for a subtask that completed abnormally or an empty
+         * optional if no subtasks completed abnormally
+         */
+        public Optional<Throwable> exception() {
+            Future<Object> f = future;
+            if (f != null) {
+                Throwable throwable = (f.state() == Future.State.FAILED)
+                        ? f.exceptionNow()
+                        : new CancellationException();
+                return Optional.of(throwable);
+            } else {
+                return Optional.empty();
+            }
+        }
+
+        /**
+         * Throws if a subtask completed abnormally. If any subtask completed with an
+         * exception then {@code ExecutionException} is thrown with the exception of the
+         * first subtask to fail as the {@linkplain Throwable#getCause() cause}. If no
+         * subtask completed with an exception but cancelled subtasks were notified to the
+         * {@code handleComplete} method then {@code CancellationException} is thrown.
+         * This method does nothing if no subtasks completed abnormally.
+         *
+         * @apiNote This method is intended to be invoked by the task scope owner after it
+         * has invoked {@link #join() join} (or {@link #joinUntil(Instant) joinUntil}).
+         * A future release may add enforcement to prevent the method being called by
+         * other threads or before joining.
+         *
+         * @throws ExecutionException if a subtask completed with an exception
+         * @throws CancellationException if no subtasks completed with an exception but
+         * subtasks were cancelled
+         */
+        public void throwIfFailed() throws ExecutionException {
+            Future<Object> f = future;
+            if (f != null) {
+                if (f.state() == Future.State.FAILED) {
+                    throw new ExecutionException(f.exceptionNow());
+                } else {
+                    throw new CancellationException();
+                }
+            }
+        }
+
+        /**
+         * Throws the exception produced by the given exception supplying function if
+         * a subtask completed abnormally. If any subtask completed with an exception then
+         * the function is invoked with the exception of the first subtask to fail.
+         * If no subtask completed with an exception but cancelled subtasks were notified
+         * to the {@code handleComplete} method then the function is called with a {@code
+         * CancellationException}. The exception returned by the function is thrown.
+         * This method does nothing if no subtasks completed abnormally.
+         *
+         * @apiNote This method is intended to be invoked by the task scope owner after it
+         * has invoked {@link #join() join} (or {@link #joinUntil(Instant) joinUntil}).
+         * A future release may add enforcement to prevent the method being called by
+         * other threads or before joining.
+         *
+         * @param esf the exception supplying function
+         * @param <X> type of the exception to be thrown
+         * @throws X produced by the exception supplying function
+         */
+        public <X extends Throwable>
+        void throwIfFailed(Function<Throwable, ? extends X> esf) throws X {
+            Objects.requireNonNull(esf);
+            Future<Object> f = future;
+            if (f != null) {
+                Throwable throwable = (f.state() == Future.State.FAILED)
+                        ? f.exceptionNow()
+                        : new CancellationException();
+                X ex = esf.apply(throwable);
+                Objects.requireNonNull(ex, "esf returned null");
+                throw ex;
+            }
+        }
+    }
+
+    /**
+     * Holder class for the virtual thread factory. It uses reflection to allow
+     * this class be compiled in an incubator module without also enabling preview
+     * features.
+     */
+    private static class FactoryHolder {
+        static final ThreadFactory VIRTUAL_THREAD_FACTORY = virtualThreadFactory();
+
+        @SuppressWarnings("removal")
+        private static ThreadFactory virtualThreadFactory() {
+            PrivilegedAction<ThreadFactory> pa = () -> {
+                try {
+                    Method ofVirtualMethod = Thread.class.getDeclaredMethod("ofVirtual");
+                    Object virtualThreadBuilder = ofVirtualMethod.invoke(null);
+                    Class<?> ofVirtualClass = Class.forName("java.lang.Thread$Builder$OfVirtual");
+                    Method factoryMethod = ofVirtualClass.getMethod("factory");
+                    return (ThreadFactory) factoryMethod.invoke(virtualThreadBuilder);
+                } catch (Exception e) {
+                    throw new InternalError(e);
+                }
+            };
+            return AccessController.doPrivileged(pa);
+        }
+    }
+}
diff --git a/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/package-info.java b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/package-info.java
new file mode 100644
index 00000000000..b51a8c12a3b
--- /dev/null
+++ b/src/jdk.incubator.concurrent/share/classes/jdk/incubator/concurrent/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+/**
+ * Defines non-final APIs for concurrent programming.
+ * {@Incubating}
+ */
+package jdk.incubator.concurrent;
diff --git a/src/jdk.incubator.concurrent/share/classes/module-info.java b/src/jdk.incubator.concurrent/share/classes/module-info.java
new file mode 100644
index 00000000000..9245c50d29c
--- /dev/null
+++ b/src/jdk.incubator.concurrent/share/classes/module-info.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+/**
+ * Defines non-final APIs for concurrent programming.
+ * {@Incubating}
+ *
+ * @moduleGraph
+ */
+module jdk.incubator.concurrent {
+    exports jdk.incubator.concurrent;
+}
+
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/DeprecatedListWriter.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/DeprecatedListWriter.java
index 574dd89a07b..1cd75e9593e 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/DeprecatedListWriter.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/DeprecatedListWriter.java
@@ -27,7 +27,6 @@
 
 import com.sun.source.doctree.DeprecatedTree;
 import java.util.List;
-import java.util.ListIterator;
 
 import javax.lang.model.element.Element;
 
@@ -81,19 +80,12 @@ public static void generate(HtmlConfiguration configuration) throws DocFileIOExc
     @Override
     protected void addExtraSection(DeprecatedAPIListBuilder list, Content content) {
         List<String> releases = configuration.deprecatedAPIListBuilder.releases;
-        if (!releases.isEmpty()) {
+        if (releases.size() > 1) {
             Content tabs = HtmlTree.DIV(HtmlStyle.checkboxes, contents.getContent(
                     "doclet.Deprecated_API_Checkbox_Label"));
             for (int i = 0; i < releases.size(); i++) {
-                int releaseIndex = i + 1;
-                String release = releases.get(i);
-                HtmlId htmlId = HtmlId.of("release-" + releaseIndex);
-                tabs.add(HtmlTree.LABEL(htmlId.name(),
-                                HtmlTree.INPUT("checkbox", htmlId)
-                                        .put(HtmlAttr.CHECKED, "")
-                                        .put(HtmlAttr.ONCLICK,
-                                                "toggleGlobal(this, '" + releaseIndex + "', 3)"))
-                        .add(HtmlTree.SPAN(Text.of(release))));
+                // Table column ids are 1-based
+                tabs.add(getReleaseCheckbox(releases.get(i), i + 1));
             }
             content.add(tabs);
         }
@@ -101,6 +93,23 @@ protected void addExtraSection(DeprecatedAPIListBuilder list, Content content) {
                 TERMINALLY_DEPRECATED_KEY, "doclet.Element", content);
     }
 
+    private Content getReleaseCheckbox(String name, int index) {
+        // Empty string represents other/uncategorized releases. Since we can't make any assumptions
+        // about release names this is arguably the safest way to avoid naming collisions.
+        boolean isOtherReleases = name.isEmpty();
+        Content releaseLabel = isOtherReleases
+                ? contents.getContent("doclet.Deprecated_API_Checkbox_Other_Releases")
+                : Text.of(name);
+        HtmlId htmlId = HtmlId.of("release-" + index);
+        String releaseId = isOtherReleases ? "" : Integer.toString(index);
+        return HtmlTree.LABEL(htmlId.name(),
+                        HtmlTree.INPUT("checkbox", htmlId)
+                                .put(HtmlAttr.CHECKED, "")
+                                .put(HtmlAttr.ONCLICK,
+                                        "toggleGlobal(this, '" + releaseId + "', 3)"))
+                .add(HtmlTree.SPAN(releaseLabel));
+    }
+
     @Override
     protected void addExtraIndexLink(DeprecatedAPIListBuilder list, Content target) {
         if (!list.getForRemoval().isEmpty()) {
@@ -122,10 +131,12 @@ protected void addComments(Element e, Content desc) {
     protected void addTableTabs(Table table, String headingKey) {
         List<String> releases = configuration.deprecatedAPIListBuilder.releases;
         if (!releases.isEmpty()) {
+            table.setGridStyle(HtmlStyle.threeColumnReleaseSummary);
+        }
+        if (releases.size() > 1) {
             table.setDefaultTab(getTableCaption(headingKey))
                     .setAlwaysShowDefaultTab(true)
-                    .setRenderTabs(false)
-                    .setGridStyle(HtmlStyle.threeColumnReleaseSummary);
+                    .setRenderTabs(false);
             for (String release : releases) {
                 Content tab = TERMINALLY_DEPRECATED_KEY.equals(headingKey)
                         ? contents.getContent("doclet.Terminally_Deprecated_In_Release", release)
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/HtmlLinkInfo.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/HtmlLinkInfo.java
index 2d4508c2290..bb9367b85cc 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/HtmlLinkInfo.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/HtmlLinkInfo.java
@@ -131,7 +131,7 @@ public enum Kind {
         EXECUTABLE_MEMBER_PARAM,
 
         /**
-         * Super interface links.
+         * Superinterface links.
          */
         SUPER_INTERFACES,
 
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/NewAPIListWriter.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/NewAPIListWriter.java
index 3944c49d32c..8c2851388b7 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/NewAPIListWriter.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/NewAPIListWriter.java
@@ -79,7 +79,7 @@ public static void generate(HtmlConfiguration configuration) throws DocFileIOExc
     @Override
     protected void addExtraSection(NewAPIBuilder list, Content content) {
         List<String> releases = configuration.newAPIPageBuilder.releases;
-        if (!releases.isEmpty()) {
+        if (releases.size() > 1) {
             Content tabs = HtmlTree.DIV(HtmlStyle.checkboxes,
                     contents.getContent("doclet.New_API_Checkbox_Label"));
             for (int i = 0; i < releases.size(); i++) {
@@ -98,12 +98,12 @@ protected void addExtraSection(NewAPIBuilder list, Content content) {
 
     @Override
     protected void addTableTabs(Table table, String headingKey) {
+        table.setGridStyle(HtmlStyle.threeColumnReleaseSummary);
         List<String> releases = configuration.newAPIPageBuilder.releases;
-        if (!releases.isEmpty()) {
+        if (releases.size() > 1) {
             table.setDefaultTab(getTableCaption(headingKey))
                     .setAlwaysShowDefaultTab(true)
-                    .setRenderTabs(false)
-                    .setGridStyle(HtmlStyle.threeColumnReleaseSummary);
+                    .setRenderTabs(false);
             for (String release : releases) {
                 table.addTab(
                         releases.size() == 1
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/PackageWriterImpl.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/PackageWriterImpl.java
index d8fcb72bae2..53582e5bf4e 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/PackageWriterImpl.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/PackageWriterImpl.java
@@ -153,7 +153,7 @@ private SortedSet<TypeElement> filterClasses(SortedSet<TypeElement> types) {
     private List<PackageElement> findRelatedPackages() {
         String pkgName = packageElement.getQualifiedName().toString();
 
-        // always add super package
+        // always add superpackage
         int lastdot = pkgName.lastIndexOf('.');
         String pkgPrefix = lastdot > 0 ? pkgName.substring(0, lastdot) : null;
         List<PackageElement> packages = new ArrayList<>(
@@ -168,7 +168,7 @@ private List<PackageElement> findRelatedPackages() {
             packages.addAll(subpackages);
         }
 
-        // only add sibling packages if there is a non-empty super package, we are beneath threshold,
+        // only add sibling packages if there is a non-empty superpackage, we are beneath threshold,
         // and number of siblings is beneath threshold as well
         if (hasSuperPackage && pkgPrefix != null && packages.size() <= MAX_SIBLING_PACKAGES) {
             Pattern siblingPattern = Pattern.compile(pkgPrefix.replace(".", "\\.") + "\\.\\w+");
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/SummaryListWriter.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/SummaryListWriter.java
index a4c49f2b1e9..927a2d13733 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/SummaryListWriter.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/SummaryListWriter.java
@@ -34,6 +34,7 @@
 import jdk.javadoc.internal.doclets.formats.html.markup.ContentBuilder;
 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlId;
 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlStyle;
+import jdk.javadoc.internal.doclets.formats.html.markup.Script;
 import jdk.javadoc.internal.doclets.formats.html.markup.TagName;
 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlTree;
 import jdk.javadoc.internal.doclets.formats.html.Navigation.PageMode;
@@ -131,6 +132,23 @@ protected void generateSummaryListFile(L summaryapi)
             }
         }
         bodyContents.addMainContent(content);
+        // The script below enables checkboxes in the page and invokes their click handler
+        // to restore any previous state when the page is loaded via back/forward button.
+        bodyContents.addMainContent(new Script("""
+                document.addEventListener("DOMContentLoaded", function(e) {
+                    document.querySelectorAll('input[type="checkbox"]').forEach(
+                        function(c) {
+                            c.disabled = false;
+                            c.onclick();
+                        });
+                    });
+                window.addEventListener("load", function(e) {
+                    document.querySelectorAll('input[type="checkbox"]').forEach(
+                        function(c) {
+                            c.onclick();
+                        });
+                    });
+                """).asContent());
         bodyContents.setFooter(getFooter());
         body.add(bodyContents);
         printHtmlDocument(null, description, body);
@@ -140,7 +158,7 @@ protected void generateSummaryListFile(L summaryapi)
      * Add the index link.
      *
      * @param id the id for the link
-     * @param headingKey
+     * @param headingKey the key for the heading content
      * @param content the content to which the index link will be added
      */
     protected void addIndexLink(HtmlId id, String headingKey, Content content) {
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/standard.properties b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/standard.properties
index d88ecf5d715..e63a7013e06 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/standard.properties
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/formats/html/resources/standard.properties
@@ -110,6 +110,7 @@ doclet.tag.invalid_input=invalid input: ''{0}''
 doclet.tag.invalid=invalid @{0}
 doclet.Deprecated_API=Deprecated API
 doclet.Deprecated_API_Checkbox_Label=Show API deprecated in:
+doclet.Deprecated_API_Checkbox_Other_Releases=other
 doclet.Deprecated_Elements=Deprecated {0}
 doclet.Deprecated_Elements_Release_Column_Header=Deprecated in
 doclet.Deprecated_In_Release=Deprecated in {0}
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/ClassWriter.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/ClassWriter.java
index 3ac1f05bd26..a887e1f6572 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/ClassWriter.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/ClassWriter.java
@@ -64,7 +64,7 @@ public interface ClassWriter {
     void addParamInfo(Content target);
 
     /**
-     * Add all super interfaces if this is an interface.
+     * Add all superinterfaces if this is an interface.
      *
      * @param target the content to which the documentation will be added
      */
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/DocletElement.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/DocletElement.java
index 32da21cf6de..5b81f5bc88d 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/DocletElement.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/DocletElement.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2022, 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
@@ -112,7 +112,7 @@ default <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationType)
     Kind getSubKind();
 
     /**
-     * Sub kind enums that this element supports.
+     * Subkind enums that this element supports.
      */
     enum Kind {
         OVERVIEW, DOCFILE;
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/ClassBuilder.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/ClassBuilder.java
index a1f1ba186a3..eee09cff359 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/ClassBuilder.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/ClassBuilder.java
@@ -170,7 +170,7 @@ protected void buildParamInfo(Content target) {
     }
 
     /**
-     * If this is an interface, list all super interfaces.
+     * If this is an interface, list all superinterfaces.
      *
      * @param target the content to which the documentation will be added
      */
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/PackageSummaryBuilder.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/PackageSummaryBuilder.java
index 4c65de4a32a..a56a4ec268d 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/PackageSummaryBuilder.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/builders/PackageSummaryBuilder.java
@@ -144,7 +144,7 @@ protected void buildSummary(Content packageContent) throws DocletException {
     }
 
     /**
-     * Builds a list of "nearby" packages (subpackages, super and sibling packages).
+     * Builds a list of "nearby" packages (subpackages, superpackages, and sibling packages).
      *
      * @param summariesList the list of summaries to which the summary will be added
      */
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/resources/script.js b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/resources/script.js
index e5d8f71b960..62953632e9c 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/resources/script.js
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/resources/script.js
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2022, 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
@@ -91,18 +91,15 @@ function sortTable(header, columnIndex, columns) {
         var ka = makeComparable(a[columnIndex].textContent);
         var kb = makeComparable(b[columnIndex].textContent);
         if (ka < kb)
-            return -1;
+            return descending ? 1 : -1;
         if (ka > kb)
-            return 1;
+            return descending ? -1 : 1;
         return 0;
     };
     var sorted = rows.sort(comparator);
-    if (descending) {
-        sorted = sorted.reverse();
-    }
     var visible = 0;
     sorted.forEach(function(row) {
-        if (row[0].style.display === '') {
+        if (row[0].style.display !== 'none') {
             var isEvenRow = visible++ % 2 === 0;
         }
         row.forEach(function(cell) {
@@ -118,11 +115,17 @@ function toggleGlobal(checkbox, selected, columns) {
     var display = checkbox.checked ? '' : 'none';
     document.querySelectorAll("div.table-tabs").forEach(function(t) {
         var id = t.parentElement.getAttribute("id");
-        selectedClass = id + "-tab" + selected;
+        var selectedClass = id + "-tab" + selected;
+        // if selected is empty string it selects all uncategorized entries
+        var selectUncategorized = !Boolean(selected);
         var visible = 0;
         document.querySelectorAll('div.' + id)
             .forEach(function(elem) {
-                if (elem.classList.contains(selectedClass)) {
+                if (selectUncategorized) {
+                    if (elem.className.indexOf(selectedClass) === -1) {
+                        elem.style.display = display;
+                    }
+                } else if (elem.classList.contains(selectedClass)) {
                     elem.style.display = display;
                 }
                 if (elem.style.display === '') {
@@ -260,9 +263,4 @@ document.addEventListener("DOMContentLoaded", function(e) {
     if (!location.hash) {
         history.replaceState(contentDiv.scrollTop, document.title);
     }
-    document.querySelectorAll('input[type="checkbox"]').forEach(
-        function(c, i) {
-            c.disabled = false;
-            toggleGlobal(c, String(i + 1), 3)
-        });
 });
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/DeprecatedAPIListBuilder.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/DeprecatedAPIListBuilder.java
index e6d7d158580..d6e8d127abf 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/DeprecatedAPIListBuilder.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/DeprecatedAPIListBuilder.java
@@ -38,17 +38,32 @@ public class DeprecatedAPIListBuilder extends SummaryAPIListBuilder {
 
     private SortedSet<Element> forRemoval;
     public final List<String> releases;
+    private final Set<String> foundReleases;
 
     /**
      * Constructor.
      *
      * @param configuration the current configuration of the doclet
-     * @param releases list of releases
+     * @param since list of releases passed via <code>--since</code> option
      */
-    public DeprecatedAPIListBuilder(BaseConfiguration configuration, List<String> releases) {
+    public DeprecatedAPIListBuilder(BaseConfiguration configuration, List<String> since) {
         super(configuration, configuration.utils::isDeprecated);
-        this.releases = releases;
+        this.foundReleases = new HashSet<>();
         buildSummaryAPIInfo();
+        // The releases list is set to the intersection of releases defined via `--since` option
+        // and actually occurring values of `Deprecated.since` in documented deprecated elements.
+        // If there are `Deprecated.since` values not contained in the `--since` option list
+        // an empty string is added to the releases list which causes the writer to generate
+        // a checkbox for other (unlisted) releases.
+        List<String> releases = new ArrayList<>(since);
+        if (!releases.isEmpty()) {
+            releases.retainAll(foundReleases);
+            if (!releases.containsAll(foundReleases)) {
+                // Empty string is added for other releases, including the default value ""
+                releases.add("");
+            }
+        }
+        this.releases = Collections.unmodifiableList(releases);
     }
 
     public SortedSet<Element> getForRemoval() {
@@ -60,6 +75,7 @@ public SortedSet<Element> getForRemoval() {
 
     @Override
     protected void handleElement(Element e) {
+        foundReleases.add(utils.getDeprecatedSince(e));
         if (utils.isDeprecatedForRemoval(e)) {
             getForRemoval().add(e);
         }
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java
index 864343ad93a..af3c5dc26b1 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/Utils.java
@@ -1102,9 +1102,9 @@ public TypeElement getFirstVisibleSuperClassAsTypeElement(TypeElement te) {
     }
 
     /**
-     * Given a class, return the closest visible super class.
+     * Given a class, return the closest visible superclass.
      * @param type the TypeMirror to be interrogated
-     * @return  the closest visible super class.  Return null if it cannot
+     * @return  the closest visible superclass.  Return null if it cannot
      *          be found.
      */
     public TypeMirror getFirstVisibleSuperClass(TypeMirror type) {
@@ -1113,10 +1113,10 @@ public TypeMirror getFirstVisibleSuperClass(TypeMirror type) {
 
 
     /**
-     * Given a class, return the closest visible super class.
+     * Given a class, return the closest visible superclass.
      *
      * @param te the TypeElement to be interrogated
-     * @return the closest visible super class.  Return null if it cannot
+     * @return the closest visible superclass.  Return null if it cannot
      *         be found.
      */
     public TypeMirror getFirstVisibleSuperClass(TypeElement te) {
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/VisibleMemberTable.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/VisibleMemberTable.java
index f7b13dfc51e..8386806d903 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/VisibleMemberTable.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/doclets/toolkit/util/VisibleMemberTable.java
@@ -75,7 +75,7 @@
  * Extra Members: these are members enclosed in an undocumented
  * package-private type element, and may not be linkable (or documented),
  * however, the members of such a type element may be documented, as if
- * declared in the sub type, only if the enclosing type is not being
+ * declared in the subtype, only if the enclosing type is not being
  * documented by a filter such as -public, -protected, etc.
  * <p>
  * Visible Members: these are the members that are "visible"
@@ -205,8 +205,8 @@ List<VisibleMemberTable> getAllSuperinterfaces() {
      * sole {@code {@inheritDoc}} or devoid of any API comments.
      * <p>
      * b.The list may contain (extra) members, inherited by inaccessible
-     * super types, primarily package private types. These members are
-     * required to be documented in the subtype when the super type is
+     * supertypes, primarily package private types. These members are
+     * required to be documented in the subtype when the supertype is
      * not documented.
      *
      * @param kind the member kind
@@ -307,12 +307,12 @@ public Set<TypeElement> getVisibleTypeElements() {
         // Add this type element first.
         result.add(te);
 
-        // Add the super classes.
+        // Add the superclasses.
         allSuperclasses.stream()
                 .map(vmt -> vmt.te)
                 .forEach(result::add);
 
-        // ... and finally the sorted super interfaces.
+        // ... and finally the sorted superinterfaces.
         allSuperinterfaces.stream()
                 .map(vmt -> vmt.te)
                 .sorted(utils.comparators.makeGeneralPurposeComparator())
@@ -419,7 +419,7 @@ private void computeParents() {
             VisibleMemberTable vmt = mcache.getVisibleMemberTable(parent);
             allSuperclasses.add(vmt);
             allSuperclasses.addAll(vmt.getAllSuperclasses());
-            // Add direct super interfaces of a super class, if any.
+            // Add direct superinterfaces of a superclass, if any.
             allSuperinterfaces.addAll(vmt.getAllSuperinterfaces());
             parents.add(vmt);
         }
diff --git a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ElementsTable.java b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ElementsTable.java
index 9d5fbad5bb9..4318b2ea404 100644
--- a/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ElementsTable.java
+++ b/src/jdk.javadoc/share/classes/jdk/javadoc/internal/tool/ElementsTable.java
@@ -483,10 +483,10 @@ ElementsTable packages(Collection<String> packageNames) {
 
     /**
      * Returns the aggregate set of included packages and specified
-     * sub packages.
+     * subpackages.
      *
      * @return the aggregate set of included packages and specified
-     * sub packages
+     * subpackages
      */
     Iterable<ModulePackage> getPackagesToParse() throws IOException {
         List<ModulePackage> result = new ArrayList<>();
diff --git a/src/jdk.jpackage/linux/native/libapplauncher/LinuxLauncherLib.cpp b/src/jdk.jpackage/linux/native/libapplauncher/LinuxLauncherLib.cpp
index 12ee1856088..52d3f2892cd 100644
--- a/src/jdk.jpackage/linux/native/libapplauncher/LinuxLauncherLib.cpp
+++ b/src/jdk.jpackage/linux/native/libapplauncher/LinuxLauncherLib.cpp
@@ -71,6 +71,18 @@ void launchApp() {
                     << _T("lib/runtime"));
     } else {
         ownerPackage.initAppLauncher(appLauncher);
+
+        tstring homeDir;
+        JP_TRY;
+        homeDir = SysInfo::getEnvVariable("HOME");
+        JP_CATCH_ALL;
+
+        if (!homeDir.empty()) {
+            appLauncher.addCfgFileLookupDir(FileUtils::mkpath()
+                    << homeDir << ".local" << ownerPackage.name());
+            appLauncher.addCfgFileLookupDir(FileUtils::mkpath()
+                    << homeDir << "." + ownerPackage.name());
+        }
     }
 
     const std::string _JPACKAGE_LAUNCHER = "_JPACKAGE_LAUNCHER";
diff --git a/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacBaseInstallerBundler.java b/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacBaseInstallerBundler.java
index 344bf0622c6..75d0b187ee3 100644
--- a/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacBaseInstallerBundler.java
+++ b/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacBaseInstallerBundler.java
@@ -46,7 +46,7 @@
 
 public abstract class MacBaseInstallerBundler extends AbstractBundler {
 
-    public final BundlerParamInfo<Path> APP_IMAGE_TEMP_ROOT =
+    private final BundlerParamInfo<Path> APP_IMAGE_TEMP_ROOT =
             new StandardBundlerParam<>(
             "mac.app.imageRoot",
             Path.class,
@@ -156,15 +156,25 @@ protected void validateAppImageAndBundeler(
     }
 
     protected Path prepareAppBundle(Map<String, ? super Object> params)
-            throws PackagerException {
+            throws PackagerException, IOException {
+        Path appDir;
+        Path appImageRoot = APP_IMAGE_TEMP_ROOT.fetchFrom(params);
         Path predefinedImage =
                 StandardBundlerParam.getPredefinedAppImage(params);
         if (predefinedImage != null) {
-            return predefinedImage;
+            appDir = appImageRoot.resolve(APP_NAME.fetchFrom(params) + ".app");
+            IOUtils.copyRecursive(predefinedImage, appDir);
+        } else {
+            appDir = appImageBundler.execute(params, appImageRoot);
+        }
+
+        if (!StandardBundlerParam.isRuntimeInstaller(params)) {
+            new PackageFile(APP_NAME.fetchFrom(params)).save(
+                    ApplicationLayout.macAppImage().resolveAt(appDir));
+           Files.deleteIfExists(AppImageFile.getPathInAppImage(appDir));
         }
-        Path appImageRoot = APP_IMAGE_TEMP_ROOT.fetchFrom(params);
 
-        return appImageBundler.execute(params, appImageRoot);
+        return appDir;
     }
 
     @Override
diff --git a/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacDmgBundler.java b/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacDmgBundler.java
index d98e367e090..c25d49f98cc 100644
--- a/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacDmgBundler.java
+++ b/src/jdk.jpackage/macosx/classes/jdk/jpackage/internal/MacDmgBundler.java
@@ -277,11 +277,8 @@ private Path buildDMG( Map<String, ? super Object> params,
         Path finalDMG = outdir.resolve(MAC_INSTALLER_NAME.fetchFrom(params)
                 + INSTALLER_SUFFIX.fetchFrom(params) + ".dmg");
 
-        Path srcFolder = APP_IMAGE_TEMP_ROOT.fetchFrom(params);
-        Path predefinedImage = StandardBundlerParam.getPredefinedAppImage(params);
-        if (predefinedImage != null) {
-            srcFolder = predefinedImage;
-        } else if (StandardBundlerParam.isRuntimeInstaller(params)) {
+        Path srcFolder = appLocation.getParent();
+        if (StandardBundlerParam.isRuntimeInstaller(params)) {
             Path newRoot = Files.createTempDirectory(TEMP_ROOT.fetchFrom(params),
                     "root-");
 
diff --git a/src/jdk.jpackage/macosx/native/applauncher/MacLauncher.cpp b/src/jdk.jpackage/macosx/native/applauncher/MacLauncher.cpp
index 5109f63604d..1d315b9f02e 100644
--- a/src/jdk.jpackage/macosx/native/applauncher/MacLauncher.cpp
+++ b/src/jdk.jpackage/macosx/native/applauncher/MacLauncher.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2022, 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
@@ -26,8 +26,10 @@
 #include "AppLauncher.h"
 #include "app.h"
 #include "FileUtils.h"
+#include "PackageFile.h"
 #include "UnixSysInfo.h"
 #include "JvmLauncher.h"
+#include "ErrorHandling.h"
 
 
 namespace {
@@ -49,17 +51,36 @@ void initJvmLauncher() {
     const tstring appImageRoot = FileUtils::dirname(FileUtils::dirname(
             FileUtils::dirname(launcherPath)));
 
+    const tstring appDirPath = FileUtils::mkpath() << appImageRoot
+            << _T("Contents/app");
+
+    const PackageFile pkgFile = PackageFile::loadFromAppDir(appDirPath);
+
     // Create JVM launcher and save in global variable.
-    jvmLauncher = AppLauncher()
+    AppLauncher appLauncher = AppLauncher()
         .setImageRoot(appImageRoot)
         .addJvmLibName(_T("Contents/Home/lib/libjli.dylib"))
         // add backup - older version such as JDK11 have it in jli sub-dir
         .addJvmLibName(_T("Contents/Home/lib/jli/libjli.dylib"))
-        .setAppDir(FileUtils::mkpath() << appImageRoot << _T("Contents/app"))
+        .setAppDir(appDirPath)
         .setLibEnvVariableName(_T("DYLD_LIBRARY_PATH"))
         .setDefaultRuntimePath(FileUtils::mkpath() << appImageRoot
-                << _T("Contents/runtime"))
-        .createJvmLauncher();
+                << _T("Contents/runtime"));
+
+    if (!pkgFile.getPackageName().empty()) {
+        tstring homeDir;
+        JP_TRY;
+        homeDir = SysInfo::getEnvVariable("HOME");
+        JP_CATCH_ALL;
+
+        if (!homeDir.empty()) {
+            appLauncher.addCfgFileLookupDir(FileUtils::mkpath()
+                    << homeDir << "Library/Application Support"
+                    << pkgFile.getPackageName());
+        }
+    }
+
+    jvmLauncher = appLauncher.createJvmLauncher();
 
     // Kick start JVM launching. The function wouldn't return!
     launchJvm();
diff --git a/src/jdk.jpackage/share/classes/jdk/jpackage/internal/PackageFile.java b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/PackageFile.java
new file mode 100644
index 00000000000..69f0ff86fba
--- /dev/null
+++ b/src/jdk.jpackage/share/classes/jdk/jpackage/internal/PackageFile.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package jdk.jpackage.internal;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.Optional;
+
+public final class PackageFile {
+
+    /**
+     * Returns path to package file.
+     * @param appImageDir - path to application image
+     */
+    public static Path getPathInAppImage(Path appImageDir) {
+        return ApplicationLayout.platformAppImage()
+                .resolveAt(appImageDir)
+                .appDirectory()
+                .resolve(FILENAME);
+    }
+
+    PackageFile(String packageName) {
+        Objects.requireNonNull(packageName);
+        this.packageName = packageName;
+    }
+
+    void save(ApplicationLayout appLayout) throws IOException {
+        Path dst = Optional.ofNullable(appLayout.appDirectory()).map(appDir -> {
+            return appDir.resolve(FILENAME);
+        }).orElse(null);
+
+        if (dst != null) {
+            Files.createDirectories(dst.getParent());
+            Files.writeString(dst, packageName);
+        }
+    }
+
+    private final String packageName;
+
+    private final static String FILENAME = ".package";
+}
diff --git a/src/jdk.jpackage/share/native/applauncher/AppLauncher.cpp b/src/jdk.jpackage/share/native/applauncher/AppLauncher.cpp
index 022a4856cdb..e1628cd0f6f 100644
--- a/src/jdk.jpackage/share/native/applauncher/AppLauncher.cpp
+++ b/src/jdk.jpackage/share/native/applauncher/AppLauncher.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2022, 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
@@ -110,9 +110,7 @@ bool AppLauncher::libEnvVariableContainsAppDir() const {
 }
 
 Jvm* AppLauncher::createJvmLauncher() const {
-    const tstring cfgFilePath = FileUtils::mkpath()
-        << appDirPath << FileUtils::stripExeSuffix(
-            FileUtils::basename(launcherPath)) + _T(".cfg");
+    const tstring cfgFilePath = getCfgFilePath();
 
     LOG_TRACE(tstrings::any() << "Launcher config file path: \""
             << cfgFilePath << "\"");
@@ -160,3 +158,20 @@ Jvm* AppLauncher::createJvmLauncher() const {
 void AppLauncher::launch() const {
     std::unique_ptr<Jvm>(createJvmLauncher())->launch();
 }
+
+
+tstring AppLauncher::getCfgFilePath() const {
+    tstring_array::const_iterator it = cfgFileLookupDirs.begin();
+    tstring_array::const_iterator end = cfgFileLookupDirs.end();
+    const tstring cfgFileName = FileUtils::stripExeSuffix(
+            FileUtils::basename(launcherPath)) + _T(".cfg");
+    for (; it != end; ++it) {
+        const tstring cfgFilePath = FileUtils::mkpath() << *it << cfgFileName;
+        LOG_TRACE(tstrings::any() << "Check [" << cfgFilePath << "] file exit");
+        if (FileUtils::isFileExists(cfgFilePath)) {
+            return cfgFilePath;
+        }
+    }
+
+    return FileUtils::mkpath() << appDirPath << cfgFileName;
+}
diff --git a/src/jdk.jpackage/share/native/applauncher/AppLauncher.h b/src/jdk.jpackage/share/native/applauncher/AppLauncher.h
index 306233a5d85..104c7609380 100644
--- a/src/jdk.jpackage/share/native/applauncher/AppLauncher.h
+++ b/src/jdk.jpackage/share/native/applauncher/AppLauncher.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2022, 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
@@ -45,6 +45,11 @@ class AppLauncher {
         return *this;
     }
 
+    AppLauncher& addCfgFileLookupDir(const tstring& v) {
+        cfgFileLookupDirs.push_back(v);
+        return *this;
+    }
+
     AppLauncher& setAppDir(const tstring& v) {
         appDirPath = v;
         return *this;
@@ -71,6 +76,9 @@ class AppLauncher {
 
     void launch() const;
 
+private:
+  tstring getCfgFilePath() const;
+
 private:
     tstring_array args;
     tstring launcherPath;
@@ -79,6 +87,7 @@ class AppLauncher {
     tstring libEnvVarName;
     tstring imageRoot;
     tstring_array jvmLibNames;
+    tstring_array cfgFileLookupDirs;
     bool initJvmFromCmdlineOnly;
 };
 
diff --git a/src/jdk.jpackage/share/native/applauncher/PackageFile.cpp b/src/jdk.jpackage/share/native/applauncher/PackageFile.cpp
new file mode 100644
index 00000000000..aa78e5f711e
--- /dev/null
+++ b/src/jdk.jpackage/share/native/applauncher/PackageFile.cpp
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+#include "kludge_c++11.h"
+
+#include <fstream>
+#include "PackageFile.h"
+#include "Log.h"
+#include "FileUtils.h"
+#include "ErrorHandling.h"
+
+
+PackageFile::PackageFile(const tstring& v): packageName(v) {
+}
+
+
+PackageFile PackageFile::loadFromAppDir(const tstring& appDirPath) {
+    tstring packageName;
+    const tstring packageFilePath =
+            FileUtils::mkpath() << appDirPath << _T(".package");
+    if (FileUtils::isFileExists(packageFilePath)) {
+        LOG_TRACE(tstrings::any() << "Read \"" << packageFilePath
+                                  << "\" package file");
+        std::ifstream input(packageFilePath);
+        if (!input.good()) {
+            JP_THROW(tstrings::any() << "Error opening \"" << packageFilePath
+                    << "\" file: " << lastCRTError());
+        }
+
+        std::string utf8line;
+        if (std::getline(input, utf8line)) {
+            LOG_TRACE(tstrings::any()
+                    << "Package name is [" << utf8line << "]");
+            packageName = tstrings::any(utf8line).tstr();
+        }
+    }
+
+    return PackageFile(packageName);
+}
diff --git a/src/jdk.jpackage/share/native/applauncher/PackageFile.h b/src/jdk.jpackage/share/native/applauncher/PackageFile.h
new file mode 100644
index 00000000000..22e6be3adef
--- /dev/null
+++ b/src/jdk.jpackage/share/native/applauncher/PackageFile.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2022, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+
+#ifndef PackageFile_h
+#define PackageFile_h
+
+#include "tstrings.h"
+
+
+class PackageFile {
+public:
+    static PackageFile loadFromAppDir(const tstring& appDirPath);
+
+    tstring getPackageName() const {
+        return packageName;
+    }
+
+private:
+    PackageFile(const tstring& packageName);
+
+private:
+    tstring packageName;
+};
+
+#endif // PackageFile_h
diff --git a/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinMsiBundler.java b/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinMsiBundler.java
index b7cf8cd7488..2cb5c2a8cc6 100644
--- a/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinMsiBundler.java
+++ b/src/jdk.jpackage/windows/classes/jdk/jpackage/internal/WinMsiBundler.java
@@ -382,10 +382,12 @@ private void prepareProto(Map<String, ? super Object> params)
                     .runtimeDirectory()
                     .resolve(Path.of("bin", "java.exe"));
         } else {
-            installerIcon = ApplicationLayout.windowsAppImage()
-                    .resolveAt(appDir)
-                    .launchersDirectory()
+            var appLayout = ApplicationLayout.windowsAppImage().resolveAt(appDir);
+
+            installerIcon = appLayout.launchersDirectory()
                     .resolve(appName + ".exe");
+
+            new PackageFile(appName).save(appLayout);
         }
         installerIcon = installerIcon.toAbsolutePath();
 
diff --git a/src/jdk.jpackage/windows/native/applauncher/WinLauncher.cpp b/src/jdk.jpackage/windows/native/applauncher/WinLauncher.cpp
index 74fe6c315e5..8f60090cfc8 100644
--- a/src/jdk.jpackage/windows/native/applauncher/WinLauncher.cpp
+++ b/src/jdk.jpackage/windows/native/applauncher/WinLauncher.cpp
@@ -35,6 +35,7 @@
 #include "WinApp.h"
 #include "Toolbox.h"
 #include "FileUtils.h"
+#include "PackageFile.h"
 #include "UniqueHandle.h"
 #include "ErrorHandling.h"
 #include "WinSysInfo.h"
@@ -133,6 +134,22 @@ tstring getJvmLibPath(const Jvm& jvm) {
 }
 
 
+void addCfgFileLookupDirForEnvVariable(
+        const PackageFile& pkgFile, AppLauncher& appLauncher,
+        const tstring& envVarName) {
+
+    tstring path;
+    JP_TRY;
+    path = SysInfo::getEnvVariable(envVarName);
+    JP_CATCH_ALL;
+
+    if (!path.empty()) {
+        appLauncher.addCfgFileLookupDir(FileUtils::mkpath() << path
+                << pkgFile.getPackageName());
+    }
+}
+
+
 void launchApp() {
     // [RT-31061] otherwise UI can be left in back of other windows.
     ::AllowSetForegroundWindow(ASFW_ANY);
@@ -141,13 +158,20 @@ void launchApp() {
     const tstring appImageRoot = FileUtils::dirname(launcherPath);
     const tstring appDirPath = FileUtils::mkpath() << appImageRoot << _T("app");
 
-    const AppLauncher appLauncher = AppLauncher().setImageRoot(appImageRoot)
+    const PackageFile pkgFile = PackageFile::loadFromAppDir(appDirPath);
+
+    AppLauncher appLauncher = AppLauncher().setImageRoot(appImageRoot)
         .addJvmLibName(_T("bin\\jli.dll"))
         .setAppDir(appDirPath)
         .setLibEnvVariableName(_T("PATH"))
         .setDefaultRuntimePath(FileUtils::mkpath() << appImageRoot
             << _T("runtime"));
 
+    if (!pkgFile.getPackageName().empty()) {
+        addCfgFileLookupDirForEnvVariable(pkgFile, appLauncher, _T("LOCALAPPDATA"));
+        addCfgFileLookupDirForEnvVariable(pkgFile, appLauncher, _T("APPDATA"));
+    }
+
     const bool restart = !appLauncher.libEnvVariableContainsAppDir();
 
     std::unique_ptr<Jvm> jvm(appLauncher.createJvmLauncher());
diff --git a/test/hotspot/gtest/opto/test_compress_expand_bits.cpp b/test/hotspot/gtest/opto/test_compress_expand_bits.cpp
new file mode 100644
index 00000000000..f5017418303
--- /dev/null
+++ b/test/hotspot/gtest/opto/test_compress_expand_bits.cpp
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2022, 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "opto/intrinsicnode.hpp"
+#include "unittest.hpp"
+
+TEST_VM(opto, compress_expand_bits) {
+  ASSERT_EQ(CompressBitsNode::compress_bits(-4LL, -1LL, 64), -4LL);
+  ASSERT_EQ(CompressBitsNode::compress_bits(-4LL, -1LL, 32), (-4LL & 0xFFFFFFFFLL));
+  ASSERT_EQ(CompressBitsNode::compress_bits(2147483647LL, -65535LL, 64), 65535LL);
+  ASSERT_EQ(CompressBitsNode::compress_bits(2147483647LL, -65535LL, 32), 65535LL);
+  ASSERT_EQ(CompressBitsNode::compress_bits(-2147483648LL, -65535LL, 64), 562949953355776LL);
+  ASSERT_EQ(CompressBitsNode::compress_bits(-2147483648LL, -65535LL, 32), 65536LL);
+  ASSERT_EQ(ExpandBitsNode::expand_bits(-4LL, -1LL, 64), -4LL);
+  ASSERT_EQ(ExpandBitsNode::expand_bits(-4LL, -1LL, 32), (-4LL & 0xFFFFFFFFLL));
+  ASSERT_EQ(ExpandBitsNode::expand_bits(2147483647LL, -65535LL, 64), 70368744112129LL);
+  ASSERT_EQ(ExpandBitsNode::expand_bits(2147483647LL, -65535LL, 32), (-65535LL & 0xFFFFFFFFLL));
+  ASSERT_EQ(ExpandBitsNode::expand_bits(-2147483648LL, -65535LL, 64), -70368744177664LL);
+  ASSERT_EQ(ExpandBitsNode::expand_bits(-2147483648LL, -65535LL, 32), 0LL);
+}
+
diff --git a/test/hotspot/gtest/utilities/test_bitMap.cpp b/test/hotspot/gtest/utilities/test_bitMap.cpp
index 80404907e90..4c33f27c312 100644
--- a/test/hotspot/gtest/utilities/test_bitMap.cpp
+++ b/test/hotspot/gtest/utilities/test_bitMap.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2022, 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
@@ -96,7 +96,7 @@ class BitMapTest {
     EXPECT_TRUE(map.is_same(map2)) << "With init_size " << init_size;
   }
 
-#ifndef PRODUCT
+#ifdef ASSERT
 
   static void testPrintOn(BitMap::idx_t size) {
     ResourceMark rm;
@@ -165,7 +165,7 @@ TEST_VM(BitMap, reinitialize) {
   BitMapTest::testReinitialize(BitMapTest::BITMAP_SIZE);
 }
 
-#ifndef PRODUCT
+#ifdef ASSERT
 
 TEST_VM(BitMap, print_on) {
   BitMapTest::testPrintOn(0);
diff --git a/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizeURShiftSubword.java b/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizeURShiftSubword.java
new file mode 100644
index 00000000000..3dc4db05187
--- /dev/null
+++ b/test/hotspot/jtreg/compiler/c2/irTests/TestVectorizeURShiftSubword.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2022, Arm Limited. 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.
+ */
+
+package compiler.c2.irTests;
+
+import compiler.lib.ir_framework.*;
+import java.util.Random;
+import jdk.test.lib.Asserts;
+import jdk.test.lib.Utils;
+
+/*
+ * @test
+ * @bug 8283307
+ * @key randomness
+ * @summary Auto-vectorization enhancement for unsigned shift right on signed subword types
+ * @requires os.arch=="amd64" | os.arch=="x86_64" | os.arch=="aarch64"
+ * @library /test/lib /
+ * @run driver compiler.c2.irTests.TestVectorizeURShiftSubword
+ */
+
+public class TestVectorizeURShiftSubword {
+
+    private static final Random RANDOM = Utils.getRandomInstance();
+
+    final private static int NUM = 3000;
+
+    private short[] shorta = new short[NUM];
+    private short[] shortb = new short[NUM];
+    private byte[] bytea = new byte[NUM];
+    private byte[] byteb = new byte[NUM];
+
+    private static final int[] SPECIALS = {
+        0, 0x1, 0x8, 0xF, 0x3F, 0x7C, 0x7F, 0x80, 0x81, 0x8F, 0xF3, 0xF8, 0xFF,
+        0x38FF, 0x3FFF, 0x8F8F, 0x8FFF, 0x7FF3, 0x7FFF, 0xFF33, 0xFFF8, 0xFFFF, 0xFFFFFF,
+        Integer.MAX_VALUE, Integer.MIN_VALUE
+    };
+
+    public byte urshift(byte input, int amount) {
+        return (byte) (input >>> amount);
+    }
+
+    public short urshift(short input, int amount) {
+        return (short) (input >>> amount);
+    }
+
+    public static void main(String[] args) {
+        TestFramework.runWithFlags("-XX:CompileCommand=exclude,*.urshift");
+    }
+
+    @Test
+    @IR(counts = {IRNode.LOAD_VECTOR, ">0", IRNode.RSHIFT_VB, ">0", IRNode.STORE_VECTOR, ">0"})
+    public void testByte0() {
+        for(int i = 0; i < NUM; i++) {
+            byteb[i] = (byte) (bytea[i] >>> 3);
+        }
+    }
+
+    @Test
+    @IR(counts = {IRNode.LOAD_VECTOR, ">0", IRNode.RSHIFT_VB, ">0", IRNode.STORE_VECTOR, ">0"})
+    public void testByte1() {
+        for(int i = 0; i < NUM; i++) {
+            byteb[i] = (byte) (bytea[i] >>> 24);
+        }
+    }
+
+    @Test
+    @IR(failOn = {IRNode.LOAD_VECTOR, IRNode.RSHIFT_VB, IRNode.STORE_VECTOR})
+    public void testByte2() {
+        for(int i = 0; i < NUM; i++) {
+            byteb[i] = (byte) (bytea[i] >>> 25);
+        }
+    }
+
+    @Test
+    @IR(counts = {IRNode.LOAD_VECTOR, ">0", IRNode.RSHIFT_VS, ">0", IRNode.STORE_VECTOR, ">0"})
+    public void testShort0() {
+        for(int i = 0; i < NUM; i++) {
+            shortb[i] = (short) (shorta[i] >>> 10);
+        }
+    }
+
+    @Test
+    @IR(counts = {IRNode.LOAD_VECTOR, ">0", IRNode.RSHIFT_VS, ">0", IRNode.STORE_VECTOR, ">0"})
+    public void testShort1() {
+        for(int i = 0; i < NUM; i++) {
+            shortb[i] = (short) (shorta[i] >>> 16);
+        }
+    }
+
+    @Test
+    @IR(failOn = {IRNode.LOAD_VECTOR, IRNode.RSHIFT_VS, IRNode.STORE_VECTOR})
+    public void testShort2() {
+        for(int i = 0; i < NUM; i++) {
+            shortb[i] = (short) (shorta[i] >>> 17);
+        }
+    }
+
+    @Test
+    public void checkTest() {
+        testByte0();
+        for (int i = 0; i < bytea.length; i++) {
+            Asserts.assertEquals(byteb[i], urshift(bytea[i], 3));
+        }
+        testByte1();
+        for (int i = 0; i < bytea.length; i++) {
+            Asserts.assertEquals(byteb[i], urshift(bytea[i], 24));
+        }
+        testByte2();
+        for (int i = 0; i < bytea.length; i++) {
+            Asserts.assertEquals(byteb[i], urshift(bytea[i], 25));
+        }
+        testShort0();
+        for (int i = 0; i < shorta.length; i++) {
+            Asserts.assertEquals(shortb[i], urshift(shorta[i], 10));
+        }
+        testShort1();
+        for (int i = 0; i < shorta.length; i++) {
+            Asserts.assertEquals(shortb[i], urshift(shorta[i], 16));
+        }
+        testShort2();
+        for (int i = 0; i < shorta.length; i++) {
+            Asserts.assertEquals(shortb[i], urshift(shorta[i], 17));
+        }
+
+    }
+
+    @Run(test = "checkTest")
+    public void checkTest_runner() {
+        for (int i = 0; i < SPECIALS.length; i++) {
+            for (int j = 0; j < shorta.length; j++) {
+                shorta[j] = (short) SPECIALS[i];
+                bytea[j] = (byte) SPECIALS[i];
+            }
+            checkTest();
+        }
+        for (int j = 0; j < shorta.length; j++) {
+            shorta[j] = (short) RANDOM.nextInt();;
+            bytea[j] = (byte) RANDOM.nextInt();
+        }
+        checkTest();
+    }
+}
diff --git a/test/hotspot/jtreg/compiler/intrinsics/TestBitShuffleOpers.java b/test/hotspot/jtreg/compiler/intrinsics/TestBitShuffleOpers.java
new file mode 100644
index 00000000000..1e3ca995ba9
--- /dev/null
+++ b/test/hotspot/jtreg/compiler/intrinsics/TestBitShuffleOpers.java
@@ -0,0 +1,504 @@
+/*
+ * Copyright (c) 2022, 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 8283894
+ * @key randomness
+ * @summary To test various transforms added for bit COMPRESS_BITS and EXPAND_BITS operations
+ * @requires vm.compiler2.enabled
+ * @requires vm.cpu.features ~= ".*bmi2.*"
+ * @requires vm.cpu.features ~= ".*bmi1.*"
+ * @requires vm.cpu.features ~= ".*sse2.*"
+ * @library /test/lib /
+ * @run driver compiler.intrinsics.TestBitShuffleOpers
+ */
+
+package compiler.intrinsics;
+
+import java.util.concurrent.Callable;
+import compiler.lib.ir_framework.*;
+import jdk.test.lib.Utils;
+import java.util.Random;
+
+public class TestBitShuffleOpers {
+    int [] ri;
+    int [] ai;
+    int [] bi;
+
+    long [] rl;
+    long [] al;
+    long [] bl;
+
+    //===================== Compress Bits Transforms ================
+    @Test
+    @IR(counts = {"RShiftI", " > 0 ", "AndI", " > 0"})
+    public void test1(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.compress(ai[i], 1 << bi[i]);
+        }
+    }
+
+    @Run(test = {"test1"}, mode = RunMode.STANDALONE)
+    public void kernel_test1() {
+        for (int i = 0; i < 5000; i++) {
+            test1(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"URShiftI", " > 0 "})
+    public void test2(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.compress(ai[i], -1 << bi[i]);
+        }
+    }
+
+    @Run(test = {"test2"}, mode = RunMode.STANDALONE)
+    public void kernel_test2() {
+        for (int i = 0; i < 5000; i++) {
+            test2(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"CompressBits", " > 0 ", "AndI" , " > 0 "})
+    public void test3(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.compress(Integer.expand(ai[i], bi[i]), bi[i]);
+        }
+    }
+
+    @Run(test = {"test3"}, mode = RunMode.STANDALONE)
+    public void kernel_test3() {
+        for (int i = 0; i < 5000; i++) {
+            test3(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"RShiftL", " > 0 ", "AndL", " > 0"})
+    public void test4(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.compress(al[i], 1L << bl[i]);
+        }
+    }
+
+    @Run(test = {"test4"}, mode = RunMode.STANDALONE)
+    public void kernel_test4() {
+        for (int i = 0; i < 5000; i++) {
+            test4(rl, al, bl);
+        }
+    }
+
+    @Test
+    @IR(counts = {"URShiftL", " > 0 "})
+    public void test5(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.compress(al[i], -1L << bl[i]);
+        }
+    }
+
+    @Run(test = {"test5"}, mode = RunMode.STANDALONE)
+    public void kernel_test5() {
+        for (int i = 0; i < 5000; i++) {
+            test5(rl, al, bl);
+        }
+    }
+
+    @Test
+    @IR(counts = {"CompressBits", " > 0 ", "AndL" , " > 0 "})
+    public void test6(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.compress(Long.expand(al[i], bl[i]), bl[i]);
+        }
+    }
+
+    @Run(test = {"test6"}, mode = RunMode.STANDALONE)
+    public void kernel_test6() {
+        for (int i = 0; i < 5000; i++) {
+            test6(rl, al, bl);
+        }
+    }
+    //===================== Expand Bits Transforms ================
+    @Test
+    @IR(counts = {"LShiftI", " > 0 ", "AndI", " > 0"})
+    public void test7(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.expand(ai[i], 1 << bi[i]);
+        }
+    }
+
+    @Run(test = {"test7"}, mode = RunMode.STANDALONE)
+    public void kernel_test7() {
+        for (int i = 0; i < 5000; i++) {
+            test7(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"LShiftI", " > 0 "})
+    public void test8(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.expand(ai[i], -1 << bi[i]);
+        }
+    }
+
+    @Run(test = {"test8"}, mode = RunMode.STANDALONE)
+    public void kernel_test8() {
+        for (int i = 0; i < 5000; i++) {
+            test8(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"AndI" , " > 0 "})
+    public void test9(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.expand(Integer.compress(ai[i], bi[i]), bi[i]);
+        }
+    }
+
+    @Run(test = {"test9"}, mode = RunMode.STANDALONE)
+    public void kernel_test9() {
+        for (int i = 0; i < 5000; i++) {
+            test9(ri, ai, bi);
+        }
+    }
+
+    @Test
+    @IR(counts = {"LShiftL", " > 0 ", "AndL", " > 0"})
+    public void test10(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.expand(al[i], 1L << bl[i]);
+        }
+    }
+
+    @Run(test = {"test10"}, mode = RunMode.STANDALONE)
+    public void kernel_test10() {
+        for (int i = 0; i < 5000; i++) {
+            test10(rl, al, bl);
+        }
+    }
+
+    @Test
+    @IR(counts = {"LShiftL", " > 0 "})
+    public void test11(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.expand(al[i], -1L << bl[i]);
+        }
+    }
+
+    @Run(test = {"test11"}, mode = RunMode.STANDALONE)
+    public void kernel_test11() {
+        for (int i = 0; i < 5000; i++) {
+            test11(rl, al, bl);
+        }
+    }
+
+    @Test
+    @IR(counts = {"AndL" , " > 0 "})
+    public void test12(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.expand(Long.compress(al[i], bl[i]), bl[i]);
+        }
+    }
+
+    @Run(test = {"test12"}, mode = RunMode.STANDALONE)
+    public void kernel_test12() {
+        for (int i = 0; i < 5000; i++) {
+            test12(rl, al, bl);
+        }
+    }
+
+    // ================ Compress/ExpandBits Vanilla ================= //
+
+    @Test
+    @IR(counts = {"CompressBits", " > 0 "})
+    public void test13(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.compress(ai[i], bi[i]);
+        }
+    }
+
+    @Run(test = {"test13"}, mode = RunMode.STANDALONE)
+    public void kernel_test13() {
+        for (int i = 0; i < 5000; i++) {
+            test13(ri, ai, bi);
+        }
+        verifyCompressInts(ri, ai, bi);
+    }
+
+    @Test
+    @IR(counts = {"CompressBits", " > 0 "})
+    public void test14(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.compress(al[i], bl[i]);
+        }
+    }
+
+    @Run(test = {"test14"}, mode = RunMode.STANDALONE)
+    public void kernel_test14() {
+        for (int i = 0; i < 5000; i++) {
+            test14(rl, al, bl);
+        }
+        verifyCompressLongs(rl, al, bl);
+    }
+
+    @Test
+    @IR(counts = {"ExpandBits", " > 0 "})
+    public void test15(int[] ri, int[] ai, int[] bi) {
+        for (int i = 0; i < ri.length; i++) {
+           ri[i] = Integer.expand(ai[i], bi[i]);
+        }
+    }
+
+    @Run(test = {"test15"}, mode = RunMode.STANDALONE)
+    public void kernel_test15() {
+        for (int i = 0; i < 5000; i++) {
+            test15(ri, ai, bi);
+        }
+        verifyExpandInts(ri, ai, bi);
+    }
+
+    @Test
+    @IR(counts = {"ExpandBits", " > 0 "})
+    public void test16(long[] rl, long[] al, long[] bl) {
+        for (int i = 0; i < rl.length; i++) {
+           rl[i] = Long.expand(al[i], bl[i]);
+        }
+    }
+
+    @Run(test = {"test16"}, mode = RunMode.STANDALONE)
+    public void kernel_test16() {
+        for (int i = 0; i < 5000; i++) {
+            test16(rl, al, bl);
+        }
+        verifyExpandLongs(rl, al, bl);
+    }
+
+    @Test
+    public void test17() {
+        int resI = 0;
+        long resL = 0L;
+        for (int i = 0; i < 5000; i++) {
+           resI = Integer.expand(-1, -1);
+           verifyExpandInt(resI, -1, -1);
+           resI = Integer.compress(-1, -1);
+           verifyCompressInt(resI, -1, -1);
+
+           resI = Integer.expand(ai[i&(SIZE-1)], -1);
+           verifyExpandInt(resI, ai[i&(SIZE-1)], -1);
+           resI = Integer.expand(ai[i&(SIZE-1)], -2);
+           verifyExpandInt(resI, ai[i&(SIZE-1)], -2);
+           resI = Integer.expand(ai[i&(SIZE-1)],  5);
+           verifyExpandInt(resI, ai[i&(SIZE-1)],  5);
+           resI = Integer.compress(ai[i&(SIZE-1)], -1);
+           verifyCompressInt(resI, ai[i&(SIZE-1)], -1);
+           resI = Integer.compress(ai[i&(SIZE-1)], -2);
+           verifyCompressInt(resI, ai[i&(SIZE-1)], -2);
+           resI = Integer.compress(ai[i&(SIZE-1)],  5);
+           verifyCompressInt(resI, ai[i&(SIZE-1)],  5);
+
+           resI = Integer.expand(ai[i&(SIZE-1)], bi[i&(SIZE-1)] & ~(0x10000000));
+           verifyExpandInt(resI, ai[i&(SIZE-1)], bi[i&(SIZE-1)] & ~(0x10000000));
+           resI = Integer.expand(ai[i&(SIZE-1)], bi[i&(SIZE-1)] | (0x10000000));
+           verifyExpandInt(resI, ai[i&(SIZE-1)], bi[i&(SIZE-1)] | (0x10000000));
+           resI = Integer.compress(ai[i&(SIZE-1)], bi[i&(SIZE-1)] & ~(0x10000000));
+           verifyCompressInt(resI, ai[i&(SIZE-1)], bi[i&(SIZE-1)] & ~(0x10000000));
+           resI = Integer.compress(ai[i&(SIZE-1)], bi[i&(SIZE-1)] | (0x10000000));
+           verifyCompressInt(resI, ai[i&(SIZE-1)], bi[i&(SIZE-1)] | (0x10000000));
+
+           resI = Integer.compress(0x12123434, 0xFF00FF00);
+           verifyCompressInt(resI, 0x12123434, 0xFF00FF00);
+           resI = Integer.expand(0x12123434, 0xFF00FF00);
+           verifyExpandInt(resI, 0x12123434, 0xFF00FF00);
+
+           resL = Long.expand(-1L, -1L);
+           verifyExpandLong(resL, -1L, -1L);
+           resL = Long.compress(-1L, -1L);
+           verifyCompressLong(resL, -1L, -1L);
+
+           resL = Long.compress(0x1212343412123434L, 0xFF00FF00FF00FF00L);
+           verifyCompressLong(resL, 0x1212343412123434L, 0xFF00FF00FF00FF00L);
+           resL = Long.expand(0x1212343412123434L, 0xFF00FF00FF00FF00L);
+           verifyExpandLong(resL, 0x1212343412123434L, 0xFF00FF00FF00FF00L);
+
+           resL = Long.expand(al[i&(SIZE-1)], -1);
+           verifyExpandLong(resL, al[i&(SIZE-1)], -1);
+           resL = Long.expand(al[i&(SIZE-1)], -2);
+           verifyExpandLong(resL, al[i&(SIZE-1)], -2);
+           resL = Long.expand(al[i&(SIZE-1)],  5);
+           verifyExpandLong(resL, al[i&(SIZE-1)],  5);
+           resL = Long.compress(al[i&(SIZE-1)], -1);
+           verifyCompressLong(resL, al[i&(SIZE-1)], -1);
+           resL = Long.compress(al[i&(SIZE-1)], -2);
+           verifyCompressLong(resL, al[i&(SIZE-1)], -2);
+           resL = Long.compress(al[i&(SIZE-1)],  5);
+           verifyCompressLong(resL, al[i&(SIZE-1)],  5);
+
+           resL = Long.expand(al[i&(SIZE-1)], bl[i&(SIZE-1)] & ~(0x10000000));
+           verifyExpandLong(resL, al[i&(SIZE-1)], bl[i&(SIZE-1)] & ~(0x10000000));
+           resL = Long.expand(al[i&(SIZE-1)], bl[i&(SIZE-1)] | (0x10000000));
+           verifyExpandLong(resL, al[i&(SIZE-1)], bl[i&(SIZE-1)] | (0x10000000));
+           resL = Long.compress(al[i&(SIZE-1)], bl[i&(SIZE-1)] & ~(0x10000000));
+           verifyCompressLong(resL, al[i&(SIZE-1)], bl[i&(SIZE-1)] & ~(0x10000000));
+           resL = Long.compress(al[i&(SIZE-1)], bl[i&(SIZE-1)] | (0x10000000));
+           verifyCompressLong(resL, al[i&(SIZE-1)], bl[i&(SIZE-1)] | (0x10000000));
+        }
+    }
+
+    private static final Random R = Utils.getRandomInstance();
+
+    static int[] fillIntRandom(Callable<int[]> factory) {
+        try {
+            int[] arr = factory.call();
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = R.nextInt();
+            }
+            return arr;
+        } catch (Exception e) {
+            throw new InternalError(e);
+        }
+    }
+    static long[] fillLongRandom(Callable<long[]> factory) {
+        try {
+            long[] arr = factory.call();
+            for (int i = 0; i < arr.length; i++) {
+                arr[i] = R.nextLong();
+            }
+            return arr;
+        } catch (Exception e) {
+            throw new InternalError(e);
+        }
+    }
+
+    static void verifyExpandInt(int actual, int src, int mask) {
+        int exp = 0;
+        for(int j = 0, k = 0; j < Integer.SIZE; j++) {
+            if ((mask & 0x1) == 1) {
+                exp |= (src & 0x1) <<  j;
+                src >>= 1;
+            }
+            mask >>= 1;
+        }
+        if (actual != exp) {
+            throw new Error("expand_int: src = " + src + " mask = " + mask +
+                            " acutal = " + actual + " expected = " + exp);
+        }
+    }
+
+    static void verifyExpandInts(int [] actual_res, int [] inp_arr, int [] mask_arr) {
+        assert inp_arr.length == mask_arr.length && inp_arr.length == actual_res.length;
+        for(int i = 0; i < actual_res.length; i++) {
+            verifyExpandInt(actual_res[i], inp_arr[i], mask_arr[i]);
+        }
+    }
+
+    static void verifyExpandLong(long actual, long src, long mask) {
+        long exp = 0;
+        for(int j = 0, k = 0; j < Long.SIZE; j++) {
+            if ((mask & 0x1) == 1) {
+                exp |= (src & 0x1) <<  j;
+                src >>= 1;
+            }
+            mask >>= 1;
+        }
+        if (actual != exp) {
+            throw new Error("expand_long: src = " + src + " mask = " + mask +
+                            " acutal = " + actual + " expected = " + exp);
+        }
+    }
+
+    static void verifyExpandLongs(long [] actual_res, long [] inp_arr, long [] mask_arr) {
+        assert inp_arr.length == mask_arr.length && inp_arr.length == actual_res.length;
+        for(int i = 0; i < actual_res.length; i++) {
+            verifyExpandLong(actual_res[i], inp_arr[i], mask_arr[i]);
+        }
+    }
+
+    static void verifyCompressInt(int actual, int src, int mask) {
+        int exp = 0;
+        for(int j = 0, k = 0; j < Integer.SIZE; j++) {
+            if ((mask & 0x1) == 1) {
+                exp |= (src & 0x1) <<  k++;
+            }
+            mask >>= 1;
+            src >>= 1;
+        }
+        if (actual != exp) {
+            throw new Error("compress_int: src = " + src + " mask = " + mask +
+                            " acutal = " + actual + " expected = " + exp);
+        }
+    }
+
+    static void verifyCompressInts(int [] actual_res, int [] inp_arr, int [] mask_arr) {
+        assert inp_arr.length == mask_arr.length && inp_arr.length == actual_res.length;
+        for(int i = 0; i < actual_res.length; i++) {
+            verifyCompressInt(actual_res[i], inp_arr[i], mask_arr[i]);
+        }
+    }
+
+    static void verifyCompressLong(long actual, long src, long mask) {
+        long exp = 0;
+        for(int j = 0, k = 0; j < Long.SIZE; j++) {
+            if ((mask & 0x1) == 1) {
+                exp |= (src & 0x1) <<  k++;
+            }
+            mask >>= 1;
+            src >>= 1;
+        }
+        if (actual != exp) {
+            throw new Error("compress_long: src = " + src + " mask = " + mask +
+                            " acutal = " + actual + " expected = " + exp);
+        }
+    }
+
+    static void verifyCompressLongs(long [] actual_res, long [] inp_arr, long [] mask_arr) {
+        assert inp_arr.length == mask_arr.length && inp_arr.length == actual_res.length;
+        for(int i = 0; i < actual_res.length; i++) {
+            verifyCompressLong(actual_res[i], inp_arr[i], mask_arr[i]);
+        }
+    }
+
+    // ===================================================== //
+
+    static final int SIZE = 512;
+
+
+    public TestBitShuffleOpers() {
+        ri = new int[SIZE];
+        ai = fillIntRandom(()-> new int[SIZE]);
+        bi = fillIntRandom(()-> new int[SIZE]);
+
+        rl = new long[SIZE];
+        al = fillLongRandom(() -> new long[SIZE]);
+        bl = fillLongRandom(() -> new long[SIZE]);
+
+    }
+
+    public static void main(String[] args) {
+        TestFramework.runWithFlags("-XX:-TieredCompilation",
+                                   "-XX:CompileThresholdScaling=0.3");
+    }
+}
diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java
index 8aaf5d4466c..9b13545163d 100644
--- a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java
+++ b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java
@@ -157,6 +157,8 @@ public class IRNode {
     public static final String RSHIFT = START + "RShift(I|L)" + MID + END;
     public static final String RSHIFT_I = START + "RShiftI" + MID + END;
     public static final String RSHIFT_L = START + "RShiftL" + MID + END;
+    public static final String RSHIFT_VB = START + "RShiftVB" + MID + END;
+    public static final String RSHIFT_VS = START + "RShiftVS" + MID + END;
     public static final String URSHIFT = START + "URShift(B|S|I|L)" + MID + END;
     public static final String URSHIFT_I = START + "URShiftI" + MID + END;
     public static final String URSHIFT_L = START + "URShiftL" + MID + END;
diff --git a/test/hotspot/jtreg/compiler/vectorization/runner/ArrayShiftOpTest.java b/test/hotspot/jtreg/compiler/vectorization/runner/ArrayShiftOpTest.java
index 21d84683d31..9d77f0dee59 100644
--- a/test/hotspot/jtreg/compiler/vectorization/runner/ArrayShiftOpTest.java
+++ b/test/hotspot/jtreg/compiler/vectorization/runner/ArrayShiftOpTest.java
@@ -133,8 +133,6 @@ public long[] variantShiftDistance() {
     }
 
     @Test
-    // Note that unsigned shift right on subword signed integer types can't
-    // be vectorized since the sign extension bits would be lost.
     public short[] vectorUnsignedShiftRight() {
         short[] res = new short[SIZE];
         for (int i = 0; i < SIZE; i++) {
diff --git a/test/hotspot/jtreg/compiler/vectorization/runner/BasicByteOpTest.java b/test/hotspot/jtreg/compiler/vectorization/runner/BasicByteOpTest.java
index 1d787ac0a5c..df92231eb11 100644
--- a/test/hotspot/jtreg/compiler/vectorization/runner/BasicByteOpTest.java
+++ b/test/hotspot/jtreg/compiler/vectorization/runner/BasicByteOpTest.java
@@ -180,8 +180,6 @@ public byte[] vectorSignedShiftRight() {
     }
 
     @Test
-    // Note that unsigned shift right on subword signed integer types can
-    // not be vectorized since the sign extension bit would be lost.
     public byte[] vectorUnsignedShiftRight() {
         byte[] res = new byte[SIZE];
         for (int i = 0; i < SIZE; i++) {
diff --git a/test/hotspot/jtreg/compiler/vectorization/runner/BasicShortOpTest.java b/test/hotspot/jtreg/compiler/vectorization/runner/BasicShortOpTest.java
index 772dc9546a4..9861ff10c86 100644
--- a/test/hotspot/jtreg/compiler/vectorization/runner/BasicShortOpTest.java
+++ b/test/hotspot/jtreg/compiler/vectorization/runner/BasicShortOpTest.java
@@ -180,8 +180,6 @@ public short[] vectorSignedShiftRight() {
     }
 
     @Test
-    // Note that unsigned shift right on subword signed integer types can
-    // not be vectorized since the sign extension bits would be lost.
     public short[] vectorUnsignedShiftRight() {
         short[] res = new short[SIZE];
         for (int i = 0; i < SIZE; i++) {
diff --git a/test/hotspot/jtreg/runtime/cds/appcds/SharedArchiveConsistency.java b/test/hotspot/jtreg/runtime/cds/appcds/SharedArchiveConsistency.java
index 46049d99b7a..bc5963653bf 100644
--- a/test/hotspot/jtreg/runtime/cds/appcds/SharedArchiveConsistency.java
+++ b/test/hotspot/jtreg/runtime/cds/appcds/SharedArchiveConsistency.java
@@ -76,7 +76,7 @@ public static String startNewArchive(String testName) {
         return newArchiveName;
     }
 
-    public static void testAndCheck(String[] execArgs) throws Exception {
+    public static void testAndCheck(String[] execArgs, String... expectedMessages) throws Exception {
         OutputAnalyzer output = shareAuto ? TestCommon.execAuto(execArgs) : TestCommon.execCommon(execArgs);
         String stdtxt = output.getOutput();
         System.out.println("Note: this test may fail in very rare occasions due to CRC32 checksum collision");
@@ -88,6 +88,9 @@ public static void testAndCheck(String[] execArgs) throws Exception {
             output.shouldNotContain("A fatal error has been detected by the Java Runtime Environment");
           }
         }
+        for (int i = 0; i < expectedMessages.length; i++) {
+            output.shouldContain(expectedMessages[i]);
+        }
         for (String message : matchMessages) {
             if (stdtxt.contains(message)) {
                 // match any to return
@@ -236,11 +239,17 @@ public static void main(String... args) throws Exception {
         testAndCheck(verifyExecArgs);
 
         // delete bytes in data section forward
-        System.out.println("\n6. Delete bytes at beginning of data section, should fail\n");
+        System.out.println("\n6a. Delete bytes at beginning of data section, should fail\n");
         String deleteBytes = startNewArchive("delete-bytes");
         CDSArchiveUtils.deleteBytesAtRandomPositionAfterHeader(orgJsaFile, deleteBytes, 4096 /*bytes*/);
         testAndCheck(verifyExecArgs);
 
+        // delete bytes at the end
+        System.out.println("\n6b. Delete bytes at the end, should fail\n");
+        deleteBytes = startNewArchive("delete-bytes-end");
+        CDSArchiveUtils.deleteBytesAtTheEnd(orgJsaFile, deleteBytes);
+        testAndCheck(verifyExecArgs, "The shared archive file has been truncated.");
+
         // modify contents in random area
         System.out.println("\n7. modify Content in random areas, should fail\n");
         String randomAreas = startNewArchive("random-areas");
diff --git a/test/hotspot/jtreg/runtime/cds/serviceability/ReplaceCriticalClasses.java b/test/hotspot/jtreg/runtime/cds/serviceability/ReplaceCriticalClasses.java
index a86aacd6908..97912bbbf5c 100644
--- a/test/hotspot/jtreg/runtime/cds/serviceability/ReplaceCriticalClasses.java
+++ b/test/hotspot/jtreg/runtime/cds/serviceability/ReplaceCriticalClasses.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2022, 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
@@ -100,7 +100,6 @@ public String[] getTests() {
             // classes even when CDS is enabled. Nothing bad should happen.
             "-notshared java/util/Locale",
             "-notshared sun/util/locale/BaseLocale",
-            "-notshared java/lang/Readable",
         };
         return tests;
     }
diff --git a/test/jdk/ProblemList-Xcomp.txt b/test/jdk/ProblemList-Xcomp.txt
index df1b9da12b0..94283fd855b 100644
--- a/test/jdk/ProblemList-Xcomp.txt
+++ b/test/jdk/ProblemList-Xcomp.txt
@@ -29,3 +29,4 @@
 
 java/lang/invoke/MethodHandles/CatchExceptionTest.java 8146623 generic-all
 java/lang/ref/ReferenceEnqueue.java 8284236 generic-all
+java/lang/ref/OOMEInReferenceHandler.java 8066859 generic-all
diff --git a/test/jdk/ProblemList.txt b/test/jdk/ProblemList.txt
index 6a683bf4ae3..e11910b5423 100644
--- a/test/jdk/ProblemList.txt
+++ b/test/jdk/ProblemList.txt
@@ -766,7 +766,6 @@ jdk/jfr/jvm/TestWaste.java                                      8282427 generic-
 # jdk_jpackage
 
 ############################################################################
-
 # Client manual tests
 
 java/awt/event/MouseEvent/SpuriousExitEnter/SpuriousExitEnter_1.java 7131438,8022539 generic-all
diff --git a/test/jdk/TEST.groups b/test/jdk/TEST.groups
index 7eea47c8405..4c921a34ce9 100644
--- a/test/jdk/TEST.groups
+++ b/test/jdk/TEST.groups
@@ -274,6 +274,7 @@ jdk_loom = \
     java/util/concurrent \
     java/net/vthread \
     java/nio/channels/vthread \
+    jdk/incubator/concurrent \
     jdk/internal/misc/ThreadFlock \
     jdk/internal/vm/Continuation \
     jdk/jfr/threading
@@ -313,6 +314,7 @@ jdk_other = \
     javax/xml \
     -javax/xml/crypto \
     jdk/dynalink \
+    jdk/incubator/concurrent \
     jdk/internal/jline \
     com/sun/jndi \
     lib/testlibrary
diff --git a/test/jdk/java/awt/dnd/DropTargetInInternalFrameTest.java b/test/jdk/java/awt/dnd/DropTargetInInternalFrameTest.java
new file mode 100644
index 00000000000..6ee0f425724
--- /dev/null
+++ b/test/jdk/java/awt/dnd/DropTargetInInternalFrameTest.java
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2000, 2022, 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.awt.Button;
+import java.awt.Component;
+import java.awt.Cursor;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Robot;
+import java.awt.Toolkit;
+import java.awt.datatransfer.DataFlavor;
+import java.awt.datatransfer.Transferable;
+import java.awt.datatransfer.UnsupportedFlavorException;
+import java.awt.dnd.DnDConstants;
+import java.awt.dnd.DragGestureEvent;
+import java.awt.dnd.DragGestureListener;
+import java.awt.dnd.DragSource;
+import java.awt.dnd.DragSourceDragEvent;
+import java.awt.dnd.DragSourceDropEvent;
+import java.awt.dnd.DragSourceEvent;
+import java.awt.dnd.DragSourceListener;
+import java.awt.dnd.DropTarget;
+import java.awt.dnd.DropTargetContext;
+import java.awt.dnd.DropTargetDragEvent;
+import java.awt.dnd.DropTargetDropEvent;
+import java.awt.dnd.DropTargetEvent;
+import java.awt.dnd.DropTargetListener;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.InputEvent;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.imageio.ImageIO;
+import javax.swing.JButton;
+import javax.swing.JDesktopPane;
+import javax.swing.JFrame;
+import javax.swing.JInternalFrame;
+import javax.swing.JPanel;
+import javax.swing.SwingUtilities;
+
+/*
+  @test
+  @bug 4395279
+  @summary Tests that a drop target in InternalFrame functions properly
+  @key headful
+  @run main DropTargetInInternalFrameTest
+*/
+public class DropTargetInInternalFrameTest implements Serializable {
+    private static final CountDownLatch dropLatch = new CountDownLatch(1);
+    private static final CountDownLatch focusLatch = new CountDownLatch(1);
+    private static JFrame frame;
+    private static JInternalFrame sourceFrame;
+    private static JInternalFrame targetFrame;
+    private static DragSourcePanel dragSourcePanel;
+    private static DropTargetPanel dropTargetPanel;
+    private static Robot robot;
+
+    private static void createUI() {
+        frame = new JFrame("Test frame");
+        sourceFrame = new JInternalFrame("Source");
+        targetFrame = new JInternalFrame("Destination");
+        dragSourcePanel = new DragSourcePanel();
+        dropTargetPanel = new DropTargetPanel(dropLatch);
+        JDesktopPane desktopPane = new JDesktopPane();
+
+        sourceFrame.getContentPane().setLayout(new GridLayout(3, 1));
+
+        // add panels to content panes
+        sourceFrame.getContentPane().add(dragSourcePanel);
+        targetFrame.getContentPane().add(dropTargetPanel);
+
+        sourceFrame.setSize(200, 200);
+        targetFrame.setSize(200, 200);
+        targetFrame
+                .setLocation(sourceFrame.getX() + sourceFrame.getWidth() + 10,
+                             sourceFrame.getY());
+
+        desktopPane.add(sourceFrame);
+        desktopPane.add(targetFrame);
+
+        frame.setTitle("Test frame");
+        frame.setBounds(200, 200, 450, 250);
+        frame.getContentPane().add(desktopPane);
+        frame.setAlwaysOnTop(true);
+        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+
+        sourceFrame.setVisible(true);
+        targetFrame.setVisible(true);
+        frame.setVisible(true);
+        dragSourcePanel.dragSourceButton.requestFocusInWindow();
+    }
+
+    public static void main(String[] argv) throws Exception {
+        SwingUtilities.invokeAndWait(DropTargetInInternalFrameTest::createUI);
+
+        robot = new Robot();
+        robot.setAutoDelay(50);
+        robot.setAutoWaitForIdle(true);
+        robot.waitForIdle();
+        if (!focusLatch.await(5, TimeUnit.SECONDS)) {
+            captureScreen();
+            SwingUtilities
+                    .invokeAndWait(DropTargetInInternalFrameTest::disposeFrame);
+            System.out.println(
+                    "Test failed, waited too long for the drag button to gain focus");
+        }
+        final AtomicReference<Point> p1Ref = new AtomicReference<>();
+        final AtomicReference<Point> p2Ref = new AtomicReference<>();
+        SwingUtilities.invokeAndWait(() -> {
+            final Point dragLocation =
+                    dragSourcePanel.dragSourceButton.getLocationOnScreen();
+            Dimension d1 = dragSourcePanel.dragSourceButton.getSize();
+            dragLocation.translate(d1.width / 2, d1.height / 2);
+            p1Ref.set(dragLocation);
+            final Point dropLocation = dropTargetPanel.getLocationOnScreen();
+            dropLocation.translate(d1.width / 2, d1.height / 2);
+            p2Ref.set(dropLocation);
+        });
+        Point p1 = p1Ref.get();
+        Point p2 = p2Ref.get();
+
+        dragAndDrop(p1, p2);
+
+        if (!dropLatch.await(5, TimeUnit.SECONDS)) {
+            captureScreen();
+            System.out.println("Test Failed, Waited too long for the Drop to complete");
+        }
+        int calledMethods = dropTargetPanel.getCalledMethods();
+        SwingUtilities
+                .invokeAndWait(DropTargetInInternalFrameTest::disposeFrame);
+        System.out.println("CalledMethods = " + calledMethods);
+        if ((calledMethods & DropTargetPanel.ENTER_CALLED) == 0) {
+            throw new RuntimeException(
+                    "Test Failed, DropTargetListener.dragEnter() not called");
+        }
+        if ((calledMethods & DropTargetPanel.OVER_CALLED) == 0) {
+            throw new RuntimeException(
+                    "Test Failed, DropTargetListener.dragOver() not called");
+        }
+        if ((calledMethods & DropTargetPanel.DROP_CALLED) == 0) {
+            throw new RuntimeException(
+                    "Test Failed, DropTargetListener.drop() not called.");
+        }
+
+        System.out.println("Test Passed");
+    }
+
+    private static void dragAndDrop(final Point p1, final Point p2) {
+        robot.mouseMove(p1.x, p1.y);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        int dx = 1;
+        while (p1.x < p2.x) {
+            p1.translate(dx, 0);
+            robot.mouseMove(p1.x, p1.y);
+            dx++;
+        }
+        robot.mouseMove(p2.x, p2.y);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+    }
+
+    private static void captureScreen() {
+        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
+        try {
+            ImageIO.write(robot.createScreenCapture(
+                    new Rectangle(0, 0, screenSize.width, screenSize.height)),
+                          "png", new File("screenImage.png"));
+        } catch (IOException ignore) {
+        }
+    }
+
+    private static void disposeFrame() {
+        sourceFrame.dispose();
+        targetFrame.dispose();
+        frame.dispose();
+    }
+
+    private static class DragSourcePanel extends JPanel {
+
+        final Dimension preferredDimension = new Dimension(200, 100);
+        final DragSourceButton dragSourceButton = new DragSourceButton();
+
+        public DragSourcePanel() {
+            setLayout(new GridLayout(1, 1));
+            dragSourceButton.addFocusListener(new FocusAdapter() {
+                @Override
+                public void focusGained(final FocusEvent e) {
+                    super.focusGained(e);
+                    focusLatch.countDown();
+                }
+            });
+            add(dragSourceButton);
+        }
+
+        public Dimension getPreferredSize() {
+            return preferredDimension;
+        }
+
+    }
+
+    private static class DropTargetPanel extends JPanel
+            implements DropTargetListener {
+
+        public static final int ENTER_CALLED = 0x1;
+        public static final int OVER_CALLED = 0x2;
+        public static final int DROP_CALLED = 0x4;
+        private final Dimension preferredDimension = new Dimension(200, 100);
+        private final CountDownLatch dropLatch;
+        private volatile int calledMethods = 0;
+
+        public DropTargetPanel(final CountDownLatch dropLatch) {
+            this.dropLatch = dropLatch;
+            setDropTarget(new DropTarget(this, this));
+        }
+
+        public Dimension getPreferredSize() {
+            return preferredDimension;
+        }
+
+        public void dragEnter(DropTargetDragEvent dtde) {
+            calledMethods |= ENTER_CALLED;
+        }
+
+        public void dragOver(DropTargetDragEvent dtde) {
+            calledMethods |= OVER_CALLED;
+        }
+
+        public void dropActionChanged(DropTargetDragEvent dtde) {
+        }
+
+        public void dragExit(DropTargetEvent dte) {
+        }
+
+        public void drop(DropTargetDropEvent dtde) {
+            System.out.println("Drop!!!!!!!!!!!! ");
+            calledMethods |= DROP_CALLED;
+            DropTargetContext dtc = dtde.getDropTargetContext();
+
+            if ((dtde.getSourceActions() & DnDConstants.ACTION_COPY) != 0) {
+                dtde.acceptDrop(DnDConstants.ACTION_COPY);
+            } else {
+                dtde.rejectDrop();
+            }
+
+            DataFlavor[] dfs = dtde.getCurrentDataFlavors();
+            Component comp = null;
+
+            if (dfs != null && dfs.length >= 1) {
+                Transferable transfer = dtde.getTransferable();
+
+                try {
+                    comp = (Component) transfer.getTransferData(dfs[0]);
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    dtc.dropComplete(false);
+                }
+            }
+            dtc.dropComplete(true);
+            add(comp);
+            dropLatch.countDown();
+        }
+
+        public int getCalledMethods() {
+            return calledMethods;
+        }
+
+    }
+
+    private static class DragSourceButton extends JButton
+            implements Serializable, Transferable, DragGestureListener,
+                       DragSourceListener {
+        private final DataFlavor dataflavor =
+                new DataFlavor(Button.class, "DragSourceButton");
+
+        public DragSourceButton() {
+            this("DragSourceButton");
+        }
+
+        public DragSourceButton(String str) {
+            super(str);
+            DragSource ds = DragSource.getDefaultDragSource();
+            ds.createDefaultDragGestureRecognizer(this,
+                                                  DnDConstants.ACTION_COPY,
+                                                  this);
+        }
+
+        public void dragGestureRecognized(DragGestureEvent dge) {
+            dge.startDrag(new Cursor(Cursor.HAND_CURSOR), this, this);
+        }
+
+        public DataFlavor[] getTransferDataFlavors() {
+            return new DataFlavor[]{dataflavor};
+        }
+
+        public boolean isDataFlavorSupported(DataFlavor dflavor) {
+            return dataflavor.equals(dflavor);
+        }
+
+        public Object getTransferData(DataFlavor flavor)
+                throws UnsupportedFlavorException, IOException {
+
+            if (!isDataFlavorSupported(flavor)) {
+                throw new UnsupportedFlavorException(flavor);
+            }
+            Object retObj;
+            ByteArrayOutputStream baoStream = new ByteArrayOutputStream();
+            ObjectOutputStream ooStream = new ObjectOutputStream(baoStream);
+            ooStream.writeObject(this);
+
+            ByteArrayInputStream baiStream =
+                    new ByteArrayInputStream(baoStream.toByteArray());
+            ObjectInputStream ois = new ObjectInputStream(baiStream);
+            try {
+                retObj = ois.readObject();
+            } catch (ClassNotFoundException e) {
+                e.printStackTrace();
+                throw new RuntimeException(e.toString());
+            }
+            return retObj;
+        }
+
+        @Override
+        public void dragEnter(final DragSourceDragEvent dsde) {
+
+        }
+
+        @Override
+        public void dragOver(final DragSourceDragEvent dsde) {
+
+        }
+
+        @Override
+        public void dropActionChanged(final DragSourceDragEvent dsde) {
+
+        }
+
+        @Override
+        public void dragExit(final DragSourceEvent dse) {
+
+        }
+
+        @Override
+        public void dragDropEnd(final DragSourceDropEvent dsde) {
+
+        }
+
+    }
+
+}
diff --git a/test/jdk/java/lang/CompressExpandSanityTest.java b/test/jdk/java/lang/CompressExpandSanityTest.java
index 8e3c37ae087..3fa78b7a1ea 100644
--- a/test/jdk/java/lang/CompressExpandSanityTest.java
+++ b/test/jdk/java/lang/CompressExpandSanityTest.java
@@ -21,10 +21,12 @@
  * questions.
  */
 
+// Disabled by default
+// @test
 /*
- * @test
  * @summary Test compress expand as if the test methods are the implementation methods
  * @key randomness
+ * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_expand_i,_expand_l,_compress_i,_compress_l CompressExpandSanityTest
  * @run testng CompressExpandSanityTest
  */
 
diff --git a/test/jdk/java/lang/CompressExpandTest.java b/test/jdk/java/lang/CompressExpandTest.java
index 90e9ff61705..6971d518979 100644
--- a/test/jdk/java/lang/CompressExpandTest.java
+++ b/test/jdk/java/lang/CompressExpandTest.java
@@ -25,6 +25,7 @@
  * @test
  * @summary Test compress expand methods
  * @key randomness
+ * @run testng/othervm -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_expand_i,_expand_l,_compress_i,_compress_l CompressExpandTest
  * @run testng CompressExpandTest
  */
 
diff --git a/test/jdk/javax/accessibility/4702233/AccessibleRoleConstants.java b/test/jdk/javax/accessibility/4702233/AccessibleRoleConstants.java
index 2cd767cec30..7f480dfab3b 100644
--- a/test/jdk/javax/accessibility/4702233/AccessibleRoleConstants.java
+++ b/test/jdk/javax/accessibility/4702233/AccessibleRoleConstants.java
@@ -1,5 +1,3 @@
-package bug4702233;
-
 /*
  * Copyright (c) 2010, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
diff --git a/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/PreviewFeaturesNotEnabled.java b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/PreviewFeaturesNotEnabled.java
new file mode 100644
index 00000000000..c02d74d1ab9
--- /dev/null
+++ b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/PreviewFeaturesNotEnabled.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022, 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 8284199
+ * @summary Test StructuredTaskScope without --enable-preview
+ * @modules jdk.incubator.concurrent
+ * @run testng/othervm PreviewFeaturesNotEnabled
+ */
+
+import jdk.incubator.concurrent.StructuredTaskScope;
+import org.testng.annotations.Test;
+import static org.testng.Assert.*;
+
+public class PreviewFeaturesNotEnabled {
+    /**
+     * One-arg constructor needs --enable-preview.
+     */
+    @Test
+    public void testUnsupportedOperationException() {
+        assertThrows(UnsupportedOperationException.class, StructuredTaskScope::new);
+    }
+
+    /**
+     * Two-arg constructor does not need --enable-preview.
+     */
+    @Test
+    public void testNoUnsupportedOperationException() {
+        try (var scope = new StructuredTaskScope<Object>(null, Thread::new)) {
+        }
+    }
+}
diff --git a/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredTaskScopeTest.java b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredTaskScopeTest.java
new file mode 100644
index 00000000000..91094b5e470
--- /dev/null
+++ b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredTaskScopeTest.java
@@ -0,0 +1,1248 @@
+/*
+ * Copyright (c) 2021, 2022, 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 8284199
+ * @summary Basic tests for StructuredTaskScope
+ * @enablePreview
+ * @modules jdk.incubator.concurrent
+ * @run testng/othervm StructuredTaskScopeTest
+ */
+
+import jdk.incubator.concurrent.StructuredTaskScope;
+import jdk.incubator.concurrent.StructuredTaskScope.ShutdownOnSuccess;
+import jdk.incubator.concurrent.StructuredTaskScope.ShutdownOnFailure;
+import jdk.incubator.concurrent.StructureViolationException;
+import java.time.Duration;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.NoSuchElementException;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import static org.testng.Assert.*;
+
+public class StructuredTaskScopeTest {
+    private ScheduledExecutorService scheduler;
+
+    @BeforeClass
+    public void setUp() throws Exception {
+        ThreadFactory factory = (task) -> {
+            Thread thread = new Thread(task);
+            thread.setDaemon(true);
+            return thread;
+        };
+        scheduler = Executors.newSingleThreadScheduledExecutor(factory);
+    }
+
+    @AfterClass
+    public void tearDown() {
+        scheduler.shutdown();
+    }
+
+    /**
+     * A provider of ThreadFactory objects for tests.
+     */
+    @DataProvider
+    public Object[][] factories() {
+        var defaultThreadFactory = Executors.defaultThreadFactory();
+        var virtualThreadFactory = Thread.ofVirtual().factory();
+        return new Object[][] {
+                { defaultThreadFactory, },
+                { virtualThreadFactory, },
+        };
+    }
+
+    /**
+     * Test that each fork creates a thread.
+     */
+    @Test(dataProvider = "factories")
+    public void testFork1(ThreadFactory factory) throws Exception {
+        AtomicInteger count = new AtomicInteger();
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            for (int i = 0; i < 100; i++) {
+                scope.fork(() -> count.incrementAndGet());
+            }
+            scope.join();
+        }
+        assertTrue(count.get() == 100);
+    }
+
+    /**
+     * Test that fork uses the specified thread factory.
+     */
+    @Test(dataProvider = "factories")
+    public void testFork2(ThreadFactory factory) throws Exception {
+        AtomicInteger count = new AtomicInteger();
+        ThreadFactory countingFactory = task -> {
+            count.incrementAndGet();
+            return factory.newThread(task);
+        };
+        try (var scope = new StructuredTaskScope(null, countingFactory)) {
+            for (int i = 0; i < 100; i++) {
+                scope.fork(() -> null);
+            }
+            scope.join();
+        }
+        assertTrue(count.get() == 100);
+    }
+
+    /**
+     * Test fork is confined to threads in the scope "tree".
+     */
+    @Test(dataProvider = "factories")
+    public void testForkConfined(ThreadFactory factory) throws Exception {
+        try (var scope1 = new StructuredTaskScope();
+             var scope2 = new StructuredTaskScope()) {
+
+            // thread in scope1 cannot fork thread in scope2
+            Future<Void> future1 = scope1.fork(() -> {
+                scope2.fork(() -> null).get();
+                return null;
+            });
+            Throwable ex = expectThrows(ExecutionException.class, future1::get);
+            assertTrue(ex.getCause() instanceof WrongThreadException);
+
+            // thread in scope2 can fork thread in scope1
+            Future<Void> future2 = scope2.fork(() -> {
+                scope1.fork(() -> null).get();
+                return null;
+            });
+            future2.get();
+            assertTrue(future2.resultNow() == null);
+
+            // random thread cannot fork
+            try (var pool = Executors.newCachedThreadPool(factory)) {
+                Future<Void> future = pool.submit(() -> {
+                    scope1.fork(() -> null);
+                    return null;
+                });
+                ex = expectThrows(ExecutionException.class, future::get);
+                assertTrue(ex.getCause() instanceof WrongThreadException);
+            }
+
+            scope2.join();
+            scope1.join();
+        }
+    }
+
+    /**
+     * Test fork when scope is shutdown.
+     */
+    @Test(dataProvider = "factories")
+    public void testForkAfterShutdown(ThreadFactory factory) throws Exception {
+        AtomicInteger count = new AtomicInteger();
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            scope.shutdown();
+            Future<String> future = scope.fork(() -> {
+                count.incrementAndGet();
+                return "foo";
+            });
+            assertTrue(future.isCancelled());
+            scope.join();
+        }
+        assertTrue(count.get() == 0);   // check that task did not run.
+    }
+
+    /**
+     * Test fork when scope is closed.
+     */
+    @Test(dataProvider = "factories")
+    public void testForkAfterClose(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            scope.join();
+            scope.close();
+            assertThrows(IllegalStateException.class, () -> scope.fork(() -> null));
+        }
+    }
+
+    /**
+     * Test fork when the thread factory rejects creating a thread.
+     */
+    @Test
+    public void testForkReject() throws Exception {
+        ThreadFactory factory = task -> null;
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            assertThrows(RejectedExecutionException.class, () -> scope.fork(() -> null));
+            scope.join();
+        }
+    }
+
+    /**
+     * A StructuredTaskScope that collects all Future objects notified to the
+     * handleComplete method.
+     */
+    private static class CollectAll<T> extends StructuredTaskScope<T> {
+        private final List<Future<T>> futures = new CopyOnWriteArrayList<>();
+
+        CollectAll(ThreadFactory factory) {
+            super(null, factory);
+        }
+
+        @Override
+        protected void handleComplete(Future<T> future) {
+            assertTrue(future.isDone());
+            futures.add(future);
+        }
+
+        Stream<Future<T>> futures() {
+            return futures.stream();
+        }
+
+        Set<Future<T>> futuresAsSet() {
+            return futures.stream().collect(Collectors.toSet());
+        }
+    }
+
+    /**
+     * Test that handleComplete method is invoked for tasks that complete normally
+     * and abnormally.
+     */
+    @Test(dataProvider = "factories")
+    public void testHandleComplete1(ThreadFactory factory) throws Exception {
+        try (var scope = new CollectAll(factory)) {
+
+            // completes normally
+            Future<String> future1 = scope.fork(() -> "foo");
+
+            // completes with exception
+            Future<String> future2 = scope.fork(() -> { throw new FooException(); });
+
+            // cancelled
+            Future<String> future3 = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return null;
+            });
+            future3.cancel(true);
+
+            scope.join();
+
+            Set<Future<String>> futures = scope.futuresAsSet();
+            assertEquals(futures, Set.of(future1, future2, future3));
+        }
+    }
+
+    /**
+     * Test that the handeComplete method is not invoked after the scope has been shutdown.
+     */
+    @Test(dataProvider = "factories")
+    public void testHandleComplete2(ThreadFactory factory) throws Exception {
+        try (var scope = new CollectAll(factory)) {
+
+            var latch = new CountDownLatch(1);
+
+            // start task that does not respond to interrupt
+            Future<String> future1 = scope.fork(() -> {
+                boolean done = false;
+                while (!done) {
+                    try {
+                        latch.await();
+                        done = true;
+                    } catch (InterruptedException e) { }
+                }
+                return null;
+            });
+
+            // start a second task to shutdown the scope after 500ms
+            Future<String> future2 = scope.fork(() -> {
+                Thread.sleep(Duration.ofMillis(500));
+                scope.shutdown();
+                return null;
+            });
+
+            scope.join();
+
+            // let task finish
+            latch.countDown();
+
+            // handleComplete should not have been called
+            assertTrue(future1.isDone());
+            assertTrue(scope.futures().count() == 0L);
+        }
+    }
+
+    /**
+     * Test join with no threads.
+     */
+    @Test
+    public void testJoinWithNoThreads() throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            scope.join();
+        }
+    }
+
+    /**
+     * Test join with threads running.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinWithThreads(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofMillis(500));
+                return "foo";
+            });
+            scope.join();
+            assertEquals(future.resultNow(), "foo");
+        }
+    }
+
+    /**
+     * Test join is owner confined.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinConfined(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            // attempt to join on thread in scope
+            Future<Void> future1 = scope.fork(() -> {
+                scope.join();
+                return null;
+            });
+            Throwable ex = expectThrows(ExecutionException.class, future1::get);
+            assertTrue(ex.getCause() instanceof WrongThreadException);
+
+            // random thread cannot join
+            try (var pool = Executors.newCachedThreadPool(factory)) {
+                Future<Void> future2 = pool.submit(() -> {
+                    scope.join();
+                    return null;
+                });
+                ex = expectThrows(ExecutionException.class, future2::get);
+                assertTrue(ex.getCause() instanceof WrongThreadException);
+            }
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test join with interrupt status set.
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptJoin1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofSeconds(3));
+                return "foo";
+            });
+
+            // join should throw
+            Thread.currentThread().interrupt();
+            try {
+                scope.join();
+                fail();
+            } catch (InterruptedException expected) {
+                assertFalse(Thread.interrupted());   // interrupt status should be clear
+            }
+
+            // join should complete
+            scope.join();
+            assertEquals(future.resultNow(), "foo");
+        }
+    }
+
+    /**
+     * Test interrupt of thread blocked in join.
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptJoin2(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofSeconds(3));
+                return "foo";
+            });
+
+            // join should throw
+            scheduleInterrupt(Thread.currentThread(), Duration.ofMillis(500));
+            try {
+                scope.join();
+                fail();
+            } catch (InterruptedException expected) {
+                assertFalse(Thread.interrupted());   // interrupt status should be clear
+            }
+
+            // join should complete
+            scope.join();
+            assertEquals(future.resultNow(), "foo");
+        }
+    }
+
+    /**
+     * Test join when scope is already shutdown.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinWithShutdown1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return "foo";
+            });
+            scope.shutdown();  // interrupts task
+            scope.join();
+
+            // task should have completed abnormally
+            assertTrue(future.isDone() && future.state() != Future.State.SUCCESS);
+        }
+    }
+
+    /**
+     * Test shutdown when owner is blocked in join.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinWithShutdown2(ThreadFactory factory) throws Exception {
+        class MyScope<T> extends StructuredTaskScope<T> {
+            MyScope(ThreadFactory factory) {
+                super(null, factory);
+            }
+            @Override
+            protected void handleComplete(Future<T> future) {
+                shutdown();
+            }
+        }
+
+        try (var scope = new MyScope(factory)) {
+            Future<String> future1 = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return "foo";
+            });
+            Future<String> future2 = scope.fork(() -> {
+                Thread.sleep(Duration.ofMillis(500));
+                return null;
+            });
+            scope.join();
+
+            // task1 should have completed abnormally
+            assertTrue(future1.isDone() && future1.state() != Future.State.SUCCESS);
+
+            // task2 should have completed normally
+            assertTrue(future2.isDone() && future2.state() == Future.State.SUCCESS);
+        }
+    }
+
+    /**
+     * Test join after scope is shutdown.
+     */
+    @Test
+    public void testJoinAfterShutdown() throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            scope.shutdown();
+            scope.join();
+        }
+    }
+
+    /**
+     * Test join after scope is closed.
+     */
+    @Test
+    public void testJoinAfterClose() throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            scope.join();
+            scope.close();
+            assertThrows(IllegalStateException.class, () -> scope.join());
+            assertThrows(IllegalStateException.class, () -> scope.joinUntil(Instant.now()));
+        }
+    }
+
+    /**
+     * Test joinUntil, threads finish before deadline expires.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinUntil1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                try {
+                    Thread.sleep(Duration.ofSeconds(2));
+                } catch (InterruptedException e) { }
+                return null;
+            });
+
+            long startMillis = millisTime();
+            scope.joinUntil(Instant.now().plusSeconds(30));
+            assertTrue(future.isDone() && future.resultNow() == null);
+            expectDuration(startMillis, /*min*/1900, /*max*/20_000);
+        }
+    }
+
+    /**
+     * Test joinUntil, deadline expires before threads finish.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinUntil2(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                try {
+                    Thread.sleep(Duration.ofSeconds(30));
+                } catch (InterruptedException e) { }
+                return null;
+            });
+
+            long startMillis = millisTime();
+            try {
+                scope.joinUntil(Instant.now().plusSeconds(2));
+            } catch (TimeoutException e) {
+                expectDuration(startMillis, /*min*/1900, /*max*/20_000);
+            }
+            assertFalse(future.isDone());
+        }
+    }
+
+    /**
+     * Test joinUntil many times.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinUntil3(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                try {
+                    Thread.sleep(Duration.ofSeconds(30));
+                } catch (InterruptedException e) { }
+                return null;
+            });
+
+            try {
+                for (int i = 0; i < 3; i++) {
+                    try {
+                        scope.joinUntil(Instant.now().plusSeconds(1));
+                        fail();
+                    } catch (TimeoutException expected) {
+                        assertFalse(future.isDone());
+                    }
+                }
+            } finally {
+                future.cancel(true);
+            }
+        }
+    }
+
+    /**
+     * Test joinUntil with a deadline that has already expired.
+     */
+    @Test(dataProvider = "factories")
+    public void testJoinUntil4(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                try {
+                    Thread.sleep(Duration.ofSeconds(30));
+                } catch (InterruptedException e) { }
+                return null;
+            });
+
+            try {
+
+                // now
+                try {
+                    scope.joinUntil(Instant.now());
+                    fail();
+                } catch (TimeoutException expected) {
+                    assertFalse(future.isDone());
+                }
+
+                // in the past
+                try {
+                    scope.joinUntil(Instant.now().minusSeconds(1));
+                    fail();
+                } catch (TimeoutException expected) {
+                    assertFalse(future.isDone());
+                }
+
+            } finally {
+                future.cancel(true);
+            }
+        }
+    }
+
+    /**
+     * Test joinUntil with interrupt status set.
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptJoinUntil1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofSeconds(3));
+                return "foo";
+            });
+
+            // join should throw
+            Thread.currentThread().interrupt();
+            try {
+                scope.joinUntil(Instant.now().plusSeconds(10));
+                fail();
+            } catch (InterruptedException expected) {
+                assertFalse(Thread.interrupted());   // interrupt status should be clear
+            }
+
+            // join should complete
+            scope.join();
+            assertEquals(future.resultNow(), "foo");
+        }
+    }
+
+    /**
+     * Test interrupt of thread blocked in joinUntil
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptJoinUntil2(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofSeconds(3));
+                return "foo";
+            });
+
+            // join should throw
+            scheduleInterrupt(Thread.currentThread(), Duration.ofMillis(500));
+            try {
+                scope.joinUntil(Instant.now().plusSeconds(10));
+                fail();
+            } catch (InterruptedException expected) {
+                assertFalse(Thread.interrupted());   // interrupt status should be clear
+            }
+
+            // join should complete
+            scope.join();
+            assertEquals(future.resultNow(), "foo");
+        }
+    }
+
+    /**
+     * Test shutdown after scope is closed.
+     */
+    public void testShutdownAfterClose() throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            scope.join();
+            scope.close();
+            assertThrows(IllegalStateException.class, () -> scope.shutdown());
+        }
+    }
+
+    /**
+     * Test shutdown is confined to threads in the scope "tree".
+     */
+    @Test(dataProvider = "factories")
+    public void testShutdownConfined(ThreadFactory factory) throws Exception {
+        try (var scope1 = new StructuredTaskScope();
+             var scope2 = new StructuredTaskScope()) {
+
+            // random thread cannot shutdown
+            try (var pool = Executors.newCachedThreadPool(factory)) {
+                Future<Void> future = pool.submit(() -> {
+                    scope1.shutdown();
+                    return null;
+                });
+                Throwable ex = expectThrows(ExecutionException.class, future::get);
+                assertTrue(ex.getCause() instanceof WrongThreadException);
+            }
+
+            // thread in scope1 cannot shutdown scope2
+            Future<Void> future1 = scope1.fork(() -> {
+                scope2.shutdown();
+                return null;
+            });
+            Throwable ex = expectThrows(ExecutionException.class, future1::get);
+            assertTrue(ex.getCause() instanceof WrongThreadException);
+
+            // thread in scope2 can shutdown scope1
+            Future<Void> future2 = scope2.fork(() -> {
+                scope1.shutdown();
+                return null;
+            });
+            future2.get();
+            assertTrue(future2.resultNow() == null);
+
+            scope2.join();
+            scope1.join();
+        }
+    }
+
+    /**
+     * Test close without join, no threads forked.
+     */
+    public void testCloseWithoutJoin1() {
+        try (var scope = new StructuredTaskScope()) {
+            // do nothing
+        }
+    }
+
+    /**
+     * Test close without join, threads forked.
+     */
+    @Test(dataProvider = "factories")
+    public void testCloseWithoutJoin2(ThreadFactory factory) {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return null;
+            });
+            assertThrows(IllegalStateException.class, scope::close);
+            assertTrue(future.isDone() && future.exceptionNow() != null);
+        }
+    }
+
+    /**
+     * Test close with threads forked after join.
+     */
+    @Test(dataProvider = "factories")
+    public void testCloseWithoutJoin3(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            scope.fork(() -> "foo");
+            scope.join();
+
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return null;
+            });
+            assertThrows(IllegalStateException.class, scope::close);
+            assertTrue(future.isDone() && future.exceptionNow() != null);
+        }
+    }
+
+    /**
+     * Test close is owner confined.
+     */
+    @Test(dataProvider = "factories")
+    public void testCloseConfined(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            // attempt to close on thread in scope
+            Future<Void> future1 = scope.fork(() -> {
+                scope.close();
+                return null;
+            });
+            Throwable ex = expectThrows(ExecutionException.class, future1::get);
+            assertTrue(ex.getCause() instanceof WrongThreadException);
+
+            // random thread cannot close scope
+            try (var pool = Executors.newCachedThreadPool(factory)) {
+                Future<Void> future2 = pool.submit(() -> {
+                    scope.close();
+                    return null;
+                });
+                ex = expectThrows(ExecutionException.class, future2::get);
+                assertTrue(ex.getCause() instanceof WrongThreadException);
+            }
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test close with interrupt status set.
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptClose1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            var latch = new CountDownLatch(1);
+
+            // start task that does not respond to interrupt
+            scope.fork(() -> {
+                boolean done = false;
+                while (!done) {
+                    try {
+                        latch.await();
+                        done = true;
+                    } catch (InterruptedException e) { }
+                }
+                return null;
+            });
+
+            scope.shutdown();
+            scope.join();
+
+            // release task after a delay
+            scheduler.schedule(latch::countDown, 1, TimeUnit.SECONDS);
+
+            // invoke close with interrupt status set
+            Thread.currentThread().interrupt();
+            try {
+                scope.close();
+            } finally {
+                assertTrue(Thread.interrupted());   // clear interrupt status
+            }
+        }
+    }
+
+    /**
+     * Test interrupting thread waiting in close.
+     */
+    @Test(dataProvider = "factories")
+    public void testInterruptClose2(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+            var latch = new CountDownLatch(1);
+
+            // start task that does not respond to interrupt
+            scope.fork(() -> {
+                boolean done = false;
+                while (!done) {
+                    try {
+                        latch.await();
+                        done = true;
+                    } catch (InterruptedException e) { }
+                }
+                return null;
+            });
+
+            scope.shutdown();
+            scope.join();
+
+            // release task after a delay
+            scheduleInterrupt(Thread.currentThread(), Duration.ofMillis(500));
+            scheduler.schedule(latch::countDown, 3, TimeUnit.SECONDS);
+            try {
+                scope.close();
+            } finally {
+                assertTrue(Thread.interrupted());   // clear interrupt status
+            }
+        }
+    }
+
+    /**
+     * Test that closing an enclosing scope closes the thread flock of a
+     * nested scope.
+     */
+    @Test
+    public void testStructureViolation1() throws Exception {
+        try (var scope1 = new StructuredTaskScope()) {
+            try (var scope2 = new StructuredTaskScope()) {
+
+                // join + close enclosing scope
+                scope1.join();
+                try {
+                    scope1.close();
+                    fail();
+                } catch (StructureViolationException expected) { }
+
+                // underlying flock should be closed, fork should return a cancelled task
+                AtomicBoolean ran = new AtomicBoolean();
+                Future<String> future = scope2.fork(() -> {
+                    ran.set(true);
+                    return null;
+                });
+                assertTrue(future.isCancelled());
+                scope2.join();
+                assertFalse(ran.get());
+            }
+        }
+    }
+
+    /**
+     * Test Future::get, task completes normally.
+     */
+    @Test(dataProvider = "factories")
+    public void testFuture1(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofMillis(100));
+                return "foo";
+            });
+
+            assertEquals(future.get(), "foo");
+            assertTrue(future.state() == Future.State.SUCCESS);
+            assertEquals(future.resultNow(), "foo");
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test Future::get, task completes with exception.
+     */
+    @Test(dataProvider = "factories")
+    public void testFuture2(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofMillis(100));
+                throw new FooException();
+            });
+
+            Throwable ex = expectThrows(ExecutionException.class, future::get);
+            assertTrue(ex.getCause() instanceof FooException);
+            assertTrue(future.state() == Future.State.FAILED);
+            assertTrue(future.exceptionNow() instanceof FooException);
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test Future::get, task is cancelled.
+     */
+    @Test(dataProvider = "factories")
+    public void testFuture3(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return null;
+            });
+
+            // timed-get, should timeout
+            try {
+                future.get(100, TimeUnit.MICROSECONDS);
+                fail();
+            } catch (TimeoutException expected) { }
+
+            future.cancel(true);
+            assertThrows(CancellationException.class, future::get);
+            assertTrue(future.state() == Future.State.CANCELLED);
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test scope shutdown with a thread blocked in Future::get.
+     */
+    @Test(dataProvider = "factories")
+    public void testFutureWithShutdown(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope(null, factory)) {
+
+            // long running task
+            Future<String> future = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return null;
+            });
+
+            // start a thread to wait in Future::get
+            AtomicBoolean waitDone = new AtomicBoolean();
+            Thread waiter = Thread.startVirtualThread(() -> {
+                try {
+                    future.get();
+                } catch (ExecutionException | CancellationException e) {
+                    waitDone.set(true);
+                } catch (InterruptedException e) {
+                    System.out.println("waiter thread interrupted!");
+                }
+            });
+
+            // shutdown scope
+            scope.shutdown();
+
+            // Future should be done and thread should be awakened
+            assertTrue(future.isDone());
+            waiter.join();
+            assertTrue(waitDone.get());
+
+            scope.join();
+        }
+    }
+
+    /**
+     * Test Future::cancel throws if invoked by a thread that is not in the tree.
+     */
+    @Test(dataProvider = "factories")
+    public void testFutureCancelConfined(ThreadFactory factory) throws Exception {
+        try (var scope = new StructuredTaskScope()) {
+            Future<String> future1 = scope.fork(() -> {
+                Thread.sleep(Duration.ofDays(1));
+                return "foo";
+            });
+
+            // random thread cannot cancel
+            try (var pool = Executors.newCachedThreadPool(factory)) {
+                Future<Void> future2 = pool.submit(() -> {
+                    future1.cancel(true);
+                    return null;
+                });
+                Throwable ex = expectThrows(ExecutionException.class, future2::get);
+                assertTrue(ex.getCause() instanceof WrongThreadException);
+            } finally {
+                future1.cancel(true);
+            }
+            scope.join();
+        }
+    }
+
+    /**
+     * Test StructuredTaskScope::toString includes the scope name.
+     */
+    @Test
+    public void testToString() throws Exception {
+        ThreadFactory factory = Thread.ofVirtual().factory();
+        try (var scope = new StructuredTaskScope("xxx", factory)) {
+            // open
+            assertTrue(scope.toString().contains("xxx"));
+
+            // shutdown
+            scope.shutdown();
+            assertTrue(scope.toString().contains("xxx"));
+
+            // closed
+            scope.join();
+            scope.close();
+            assertTrue(scope.toString().contains("xxx"));
+        }
+    }
+
+    /**
+     * Test for NullPointerException.
+     */
+    @Test
+    public void testNulls() throws Exception {
+        assertThrows(NullPointerException.class, () -> new StructuredTaskScope("", null));
+        try (var scope = new StructuredTaskScope()) {
+            assertThrows(NullPointerException.class, () -> scope.fork(null));
+            assertThrows(NullPointerException.class, () -> scope.joinUntil(null));
+        }
+
+        assertThrows(NullPointerException.class, () -> new ShutdownOnSuccess("", null));
+        try (var scope = new ShutdownOnSuccess<Object>()) {
+            assertThrows(NullPointerException.class, () -> scope.fork(null));
+            assertThrows(NullPointerException.class, () -> scope.joinUntil(null));
+            assertThrows(NullPointerException.class, () -> scope.result(null));
+        }
+
+        assertThrows(NullPointerException.class, () -> new ShutdownOnFailure("", null));
+        try (var scope = new ShutdownOnFailure()) {
+            assertThrows(NullPointerException.class, () -> scope.fork(null));
+            assertThrows(NullPointerException.class, () -> scope.joinUntil(null));
+            assertThrows(NullPointerException.class, () -> scope.throwIfFailed(null));
+        }
+    }
+
+    /**
+     * Test ShutdownOnSuccess with no completed tasks.
+     */
+    @Test
+    public void testShutdownOnSuccess1() throws Exception {
+        try (var scope = new ShutdownOnSuccess<String>()) {
+            assertThrows(IllegalStateException.class, () -> scope.result());
+            assertThrows(IllegalStateException.class, () -> scope.result(e -> null));
+        }
+    }
+
+    /**
+     * Test ShutdownOnSuccess with tasks that completed normally.
+     */
+    @Test
+    public void testShutdownOnSuccess2() throws Exception {
+        try (var scope = new ShutdownOnSuccess<String>()) {
+
+            // two tasks complete normally
+            scope.fork(() -> "foo");
+            scope.join();  // ensures foo completes first
+            scope.fork(() -> "bar");
+            scope.join();
+
+            assertEquals(scope.result(), "foo");
+            assertEquals(scope.result(e -> null), "foo");
+        }
+    }
+
+    /**
+     * Test ShutdownOnSuccess with tasks that completed normally and abnormally.
+     */
+    @Test
+    public void testShutdownOnSuccess3() throws Exception {
+        try (var scope = new ShutdownOnSuccess<String>()) {
+
+            // one task completes normally, the other with an exception
+            scope.fork(() -> "foo");
+            scope.fork(() -> { throw new ArithmeticException(); });
+            scope.join();
+
+            assertEquals(scope.result(), "foo");
+            assertEquals(scope.result(e -> null), "foo");
+        }
+    }
+
+    /**
+     * Test ShutdownOnSuccess with a task that completed with an exception.
+     */
+    @Test
+    public void testShutdownOnSuccess4() throws Exception {
+        try (var scope = new ShutdownOnSuccess<String>()) {
+
+            // tasks completes with exception
+            scope.fork(() -> { throw new ArithmeticException(); });
+            scope.join();
+
+            Throwable ex = expectThrows(ExecutionException.class, () -> scope.result());
+            assertTrue(ex.getCause() instanceof  ArithmeticException);
+
+            ex = expectThrows(FooException.class, () -> scope.result(e -> new FooException(e)));
+            assertTrue(ex.getCause() instanceof  ArithmeticException);
+        }
+    }
+
+    /**
+     * Test ShutdownOnSuccess with a cancelled task.
+     */
+    @Test
+    public void testShutdownOnSuccess5() throws Exception {
+        try (var scope = new ShutdownOnSuccess<String>()) {
+
+            // cancelled task
+            var future = scope.fork(() -> {
+                Thread.sleep(60_000);
+                return null;
+            });
+            future.cancel(false);
+
+            scope.join();
+
+            assertThrows(CancellationException.class, () -> scope.result());
+            Throwable ex = expectThrows(FooException.class,
+                                        () -> scope.result(e -> new FooException(e)));
+            assertTrue(ex.getCause() instanceof CancellationException);
+        }
+    }
+
+    /**
+     * Test ShutdownOnFailure with no completed tasks.
+     */
+    @Test
+    public void testShutdownOnFailure1() throws Throwable {
+        try (var scope = new ShutdownOnFailure()) {
+            assertTrue(scope.exception().isEmpty());
+            scope.throwIfFailed();
+            scope.throwIfFailed(e -> new FooException(e));
+        }
+    }
+
+    /**
+     * Test ShutdownOnFailure with tasks that completed normally.
+     */
+    @Test
+    public void testShutdownOnFailure2() throws Throwable {
+        try (var scope = new ShutdownOnFailure()) {
+            scope.fork(() -> "foo");
+            scope.fork(() -> "bar");
+            scope.join();
+
+            // no exception
+            assertTrue(scope.exception().isEmpty());
+            scope.throwIfFailed();
+            scope.throwIfFailed(e -> new FooException(e));
+        }
+    }
+
+    /**
+     * Test ShutdownOnFailure with tasks that completed normally and abnormally.
+     */
+    @Test
+    public void testShutdownOnFailure3() throws Throwable {
+        try (var scope = new ShutdownOnFailure()) {
+
+            // one task completes normally, the other with an exception
+            scope.fork(() -> "foo");
+            scope.fork(() -> { throw new ArithmeticException(); });
+            scope.join();
+
+            Throwable ex = scope.exception().orElse(null);
+            assertTrue(ex instanceof ArithmeticException);
+
+            ex = expectThrows(ExecutionException.class, () -> scope.throwIfFailed());
+            assertTrue(ex.getCause() instanceof ArithmeticException);
+
+            ex = expectThrows(FooException.class,
+                              () -> scope.throwIfFailed(e -> new FooException(e)));
+            assertTrue(ex.getCause() instanceof ArithmeticException);
+        }
+    }
+
+    /**
+     * Test ShutdownOnFailure with a cancelled task.
+     */
+    @Test
+    public void testShutdownOnFailure4() throws Throwable {
+        try (var scope = new ShutdownOnFailure()) {
+
+            var future = scope.fork(() -> {
+                Thread.sleep(60_000);
+                return null;
+            });
+            future.cancel(false);
+
+            scope.join();
+
+            Throwable ex = scope.exception().orElse(null);
+            assertTrue(ex instanceof CancellationException);
+
+            assertThrows(CancellationException.class, () -> scope.throwIfFailed());
+
+            ex = expectThrows(FooException.class,
+                              () -> scope.throwIfFailed(e -> new FooException(e)));
+            assertTrue(ex.getCause() instanceof CancellationException);
+        }
+    }
+
+    /**
+     * A runtime exception for tests.
+     */
+    private static class FooException extends RuntimeException {
+        FooException() { }
+        FooException(Throwable cause) { super(cause); }
+    }
+
+    /**
+     * Schedules a thread to be interrupted after the given delay.
+     */
+    private void scheduleInterrupt(Thread thread, Duration delay) {
+        long millis = delay.toMillis();
+        scheduler.schedule(thread::interrupt, millis, TimeUnit.MILLISECONDS);
+    }
+
+    /**
+     * Returns the current time in milliseconds.
+     */
+    private static long millisTime() {
+        long now = System.nanoTime();
+        return TimeUnit.MILLISECONDS.convert(now, TimeUnit.NANOSECONDS);
+    }
+
+    /**
+     * Check the duration of a task
+     * @param start start time, in milliseconds
+     * @param min minimum expected duration, in milliseconds
+     * @param max maximum expected duration, in milliseconds
+     * @return the duration (now - start), in milliseconds
+     */
+    private static long expectDuration(long start, long min, long max) {
+        long duration = millisTime() - start;
+        assertTrue(duration >= min,
+                "Duration " + duration + "ms, expected >= " + min + "ms");
+        assertTrue(duration <= max,
+                "Duration " + duration + "ms, expected <= " + max + "ms");
+        return duration;
+    }
+}
diff --git a/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredThreadDumpTest.java b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredThreadDumpTest.java
new file mode 100644
index 00000000000..be737170e83
--- /dev/null
+++ b/test/jdk/jdk/incubator/concurrent/StructuredTaskScope/StructuredThreadDumpTest.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2022, 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 8284199
+ * @summary Test thread dumps with StructuredTaskScope
+ * @enablePreview
+ * @modules jdk.incubator.concurrent
+ * @library /test/lib
+ * @run testng/othervm StructuredThreadDumpTest
+ */
+
+import jdk.incubator.concurrent.StructuredTaskScope;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
+import java.util.stream.Stream;
+import com.sun.management.HotSpotDiagnosticMXBean;
+import com.sun.management.HotSpotDiagnosticMXBean.ThreadDumpFormat;
+import jdk.test.lib.threaddump.ThreadDump;
+import org.testng.annotations.Test;
+import static org.testng.Assert.*;
+
+public class StructuredThreadDumpTest {
+
+    /**
+     * Test that a thread dump with a tree of task scopes contains a thread grouping for
+     * each task scope.
+     */
+    @Test
+    public void testTree() throws Exception {
+        ThreadFactory factory = Thread.ofVirtual().factory();
+        try (var scope = new StructuredTaskScope<>("scope", factory)) {
+            Thread thread1 = fork(scope, "child-scope-A");
+            Thread thread2 = fork(scope, "child-scope-B");
+            try {
+                ThreadDump threadDump = threadDump();
+
+                // thread dump should have a thread container for each scope
+                var rootContainer = threadDump.rootThreadContainer();
+                var container1 = threadDump.findThreadContainer("scope").orElseThrow();
+                var container2 = threadDump.findThreadContainer("child-scope-A").orElseThrow();
+                var container3 = threadDump.findThreadContainer("child-scope-B").orElseThrow();
+
+                // check parents
+                assertFalse(rootContainer.parent().isPresent());
+                assertTrue(container1.parent().get() == rootContainer);
+                assertTrue(container2.parent().get() == container1);
+                assertTrue(container3.parent().get() == container1);
+
+                // check owners
+                assertFalse(rootContainer.owner().isPresent());
+                assertTrue(container1.owner().getAsLong() == Thread.currentThread().threadId());
+                assertTrue(container2.owner().getAsLong() == thread1.threadId());
+                assertTrue(container3.owner().getAsLong() == thread2.threadId());
+
+                // thread1 and threads2 should be in threads array of "scope"
+                container1.findThread(thread1.threadId()).orElseThrow();
+                container1.findThread(thread2.threadId()).orElseThrow();
+
+            } finally {
+                scope.shutdown();
+                scope.join();
+            }
+        }
+    }
+
+    /**
+     * Test that a thread dump with nested tasks scopes contains a thread grouping for
+     * each task scope.
+     */
+    @Test
+    public void testNested() throws Exception {
+        ThreadFactory factory = Thread.ofVirtual().factory();
+        try (var scope1 = new StructuredTaskScope<>("scope-A", factory)) {
+            Thread thread1 = fork(scope1);
+
+            try (var scope2 = new StructuredTaskScope<>("scope-B", factory)) {
+                Thread thread2 = fork(scope2);
+                try {
+                    ThreadDump threadDump = threadDump();
+
+                    // thread dump should have a thread container for both scopes
+                    var rootContainer = threadDump.rootThreadContainer();
+                    var container1 = threadDump.findThreadContainer("scope-A").orElseThrow();
+                    var container2 = threadDump.findThreadContainer("scope-B").orElseThrow();
+
+                    // check parents
+                    assertFalse(rootContainer.parent().isPresent());
+                    assertTrue(container1.parent().get() == rootContainer);
+                    assertTrue(container2.parent().get() == container1);
+
+                    // check owners
+                    long tid = Thread.currentThread().threadId();
+                    assertFalse(rootContainer.owner().isPresent());
+                    assertTrue(container1.owner().getAsLong() == tid);
+                    assertTrue(container2.owner().getAsLong() == tid);
+
+                    // thread1 should be in threads array of "scope-A"
+                    container1.findThread(thread1.threadId()).orElseThrow();
+
+                    // thread2 should be in threads array of "scope-B"
+                    container2.findThread(thread2.threadId()).orElseThrow();
+
+                } finally {
+                    scope2.shutdown();
+                    scope2.join();
+                }
+            } finally {
+                scope1.shutdown();
+                scope1.join();
+            }
+        }
+    }
+
+    /**
+     * Generates a JSON formatted thread dump to a temporary file, prints it to standard
+     * output, parses the JSON text and returns a ThreadDump object for the thread dump.
+     */
+    private static ThreadDump threadDump() throws IOException {
+        Path dir = Path.of(".").toAbsolutePath();
+        Path file = Files.createTempFile(dir, "threadump", "json");
+        Files.delete(file);
+        ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class)
+                .dumpThreads(file.toString(), ThreadDumpFormat.JSON);
+
+        try (Stream<String> stream = Files.lines(file)) {
+            stream.forEach(System.out::println);
+        }
+
+        String jsonText = Files.readString(file);
+        return ThreadDump.parse(jsonText);
+    }
+
+    /**
+     * Forks a subtask in the given scope that parks, returning the Thread that executes
+     * the subtask.
+     */
+    private static Thread fork(StructuredTaskScope<Object> scope) throws Exception {
+        var ref = new AtomicReference<Thread>();
+        scope.fork(() -> {
+            ref.set(Thread.currentThread());
+            LockSupport.park();
+            return null;
+        });
+        Thread thread;
+        while ((thread = ref.get()) == null) {
+            Thread.sleep(10);
+        }
+        return thread;
+    }
+
+    /**
+     * Forks a subtask in the given scope. The subtask creates a new child scope with
+     * the given name, then parks. This method returns Thread that executes the subtask.
+     */
+    private static Thread fork(StructuredTaskScope<Object> scope,
+                               String childScopeName) throws Exception {
+        var ref = new AtomicReference<Thread>();
+        scope.fork(() -> {
+            ThreadFactory factory = Thread.ofVirtual().factory();
+            try (var childScope = new StructuredTaskScope<Object>(childScopeName, factory)) {
+                ref.set(Thread.currentThread());
+                LockSupport.park();
+            }
+            return null;
+        });
+        Thread thread;
+        while ((thread = ref.get()) == null) {
+            Thread.sleep(10);
+        }
+        return thread;
+    }
+
+}
diff --git a/test/jdk/sun/java2d/cmm/ColorConvertOp/MTPerLineTransformValidation.java b/test/jdk/sun/java2d/cmm/ColorConvertOp/MTPerLineTransformValidation.java
index 821bd0acaa7..43c79e16be1 100644
--- a/test/jdk/sun/java2d/cmm/ColorConvertOp/MTPerLineTransformValidation.java
+++ b/test/jdk/sun/java2d/cmm/ColorConvertOp/MTPerLineTransformValidation.java
@@ -29,7 +29,7 @@
  * @test
  * @bug 8273972
  * @summary Verifies that ColorConvertOp works fine if shared between threads
- * @run main/othervm/timeout=600 MTTransformValidation
+ * @run main/othervm/timeout=600 MTPerLineTransformValidation
  */
 public final class MTPerLineTransformValidation {
 
diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java
index be56ea1c31f..6e1329e4739 100644
--- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java
+++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/JPackageCommand.java
@@ -47,6 +47,7 @@
 import java.util.stream.Stream;
 import jdk.jpackage.internal.AppImageFile;
 import jdk.jpackage.internal.ApplicationLayout;
+import jdk.jpackage.internal.PackageFile;
 import static jdk.jpackage.test.AdditionalLauncher.forEachAdditionalLauncher;
 import jdk.jpackage.test.Functional.ThrowingConsumer;
 import jdk.jpackage.test.Functional.ThrowingFunction;
@@ -761,38 +762,8 @@ public JPackageCommand assertImageCreated() {
     }
 
     JPackageCommand assertAppLayout() {
-        if (isPackageUnpacked() || isImagePackageType()) {
-            final Path rootDir = isPackageUnpacked() ? pathToUnpackedPackageFile(
-                    appInstallationDirectory()) : outputBundle();
-            final Path appImageFileName = AppImageFile.getPathInAppImage(
-                    Path.of("")).getFileName();
-            try (Stream<Path> walk = ThrowingSupplier.toSupplier(
-                    () -> Files.walk(rootDir)).get()) {
-                List<String> appImageFiles = walk
-                        .filter(path -> path.getFileName().equals(appImageFileName))
-                        .map(Path::toString)
-                        .collect(Collectors.toList());
-                if (isImagePackageType() || (TKit.isOSX() && !isRuntime())) {
-                    List<String> expected = List.of(
-                            AppImageFile.getPathInAppImage(rootDir).toString());
-                    TKit.assertStringListEquals(expected, appImageFiles,
-                            String.format(
-                                    "Check there is only one file with [%s] name in the package",
-                                    appImageFileName));
-                } else {
-                    TKit.assertStringListEquals(List.of(), appImageFiles,
-                            String.format(
-                                    "Check there are no files with [%s] name in the package",
-                                    appImageFileName));
-                }
-            }
-        } else if (TKit.isOSX() && !isRuntime()) {
-            TKit.assertFileExists(AppImageFile.getPathInAppImage(
-                    appInstallationDirectory()));
-        } else {
-            TKit.assertPathExists(AppImageFile.getPathInAppImage(
-                    appInstallationDirectory()), false);
-        }
+        assertAppImageFile();
+        assertPackageFile();
 
         TKit.assertDirectoryExists(appRuntimeDirectory());
 
@@ -809,6 +780,54 @@ JPackageCommand assertAppLayout() {
         return this;
     }
 
+    private void assertAppImageFile() {
+        final Path lookupPath = AppImageFile.getPathInAppImage(Path.of(""));
+
+        if (isRuntime() || !isImagePackageType()) {
+            assertFileInAppImage(lookupPath, null);
+        } else {
+            assertFileInAppImage(lookupPath, lookupPath);
+        }
+    }
+
+    private void assertPackageFile() {
+        final Path lookupPath = PackageFile.getPathInAppImage(Path.of(""));
+
+        if (isRuntime() || isImagePackageType() || TKit.isLinux()) {
+            assertFileInAppImage(lookupPath, null);
+        } else {
+            assertFileInAppImage(lookupPath, lookupPath);
+        }
+    }
+
+    private void assertFileInAppImage(Path filename, Path expectedPath) {
+        if (filename.getNameCount() > 1) {
+            assertFileInAppImage(filename.getFileName(), expectedPath);
+            return;
+        }
+
+        final Path rootDir = isImagePackageType() ? outputBundle() : pathToUnpackedPackageFile(
+                appInstallationDirectory());
+
+        try ( Stream<Path> walk = ThrowingSupplier.toSupplier(() -> Files.walk(
+                rootDir)).get()) {
+            List<String> files = walk.filter(path -> path.getFileName().equals(
+                    filename)).map(Path::toString).toList();
+
+            if (expectedPath == null) {
+                TKit.assertStringListEquals(List.of(), files, String.format(
+                        "Check there are no files with [%s] name in the package",
+                        filename));
+            } else {
+                List<String> expected = List.of(
+                        rootDir.resolve(expectedPath).toString());
+                TKit.assertStringListEquals(expected, files, String.format(
+                        "Check there is only one file with [%s] name in the package",
+                        filename));
+            }
+        }
+    }
+
     JPackageCommand setUnpackedPackageLocation(Path path) {
         verifyIsOfType(PackageType.NATIVE);
         if (path != null) {
diff --git a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
index 2c7def61494..60492b2529f 100644
--- a/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
+++ b/test/jdk/tools/jpackage/helpers/jdk/jpackage/test/TKit.java
@@ -22,6 +22,7 @@
  */
 package jdk.jpackage.test;
 
+import java.io.Closeable;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -46,6 +47,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
@@ -769,6 +771,34 @@ public static void assertStringListEquals(List<String> expected,
         }
     }
 
+    /**
+     * Creates a directory by creating all nonexistent parent directories first
+     * just like java.nio.file.Files#createDirectories() and returns
+     * java.io.Closeable that will delete all created nonexistent parent
+     * directories.
+     */
+    public static Closeable createDirectories(Path dir) throws IOException {
+        Objects.requireNonNull(dir);
+
+        Collection<Path> dirsToDelete = new ArrayList<>();
+
+        Path curDir = dir;
+        while (!Files.exists(curDir)) {
+            dirsToDelete.add(curDir);
+            curDir = curDir.getParent();
+        }
+        Files.createDirectories(dir);
+
+        return new Closeable() {
+            @Override
+            public void close() throws IOException {
+                for (var dirToDelete : dirsToDelete) {
+                    Files.deleteIfExists(dirToDelete);
+                }
+            }
+        };
+    }
+
     public final static class TextStreamVerifier {
         TextStreamVerifier(String value) {
             this.value = value;
diff --git a/test/jdk/tools/jpackage/run_tests.sh b/test/jdk/tools/jpackage/run_tests.sh
index 2639f38cd68..bee01924d73 100644
--- a/test/jdk/tools/jpackage/run_tests.sh
+++ b/test/jdk/tools/jpackage/run_tests.sh
@@ -254,6 +254,14 @@ if [ -z "$run_all_tests" ]; then
   jtreg_args+=(-Djpackage.test.SQETest=yes)
 fi
 
+if [ -n "$APPDATA" ]; then
+  # Looks like this is Windows.
+  # Explicitly add LOCALAPPDATA and APPDATA environment variables to the list
+  # of environment variables jtreg will pass to tests as by default it will not.
+  # This is needed for PerUserCfgTest test.
+  jtreg_args+=("-e:LOCALAPPDATA,APPDATA")
+fi
+
 jtreg_args+=("$test_actions")
 
 # Drop arguments separator
diff --git a/test/jdk/tools/jpackage/share/PerUserCfgTest.java b/test/jdk/tools/jpackage/share/PerUserCfgTest.java
new file mode 100644
index 00000000000..9d249a1458a
--- /dev/null
+++ b/test/jdk/tools/jpackage/share/PerUserCfgTest.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2022, 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.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Optional;
+import jdk.jpackage.test.AdditionalLauncher;
+import jdk.jpackage.test.PackageTest;
+import jdk.jpackage.test.Annotations.Test;
+import jdk.jpackage.test.Functional.ThrowingConsumer;
+import jdk.jpackage.test.HelloApp;
+import jdk.jpackage.test.JPackageCommand;
+import jdk.jpackage.test.LinuxHelper;
+import jdk.jpackage.test.PackageType;
+import jdk.jpackage.test.TKit;
+
+/**
+ * Test per-user configuration of app launchers created by jpackage.
+ */
+
+/*
+ * @test
+ * @summary pre-user configuration of app launchers
+ * @library ../helpers
+ * @key jpackagePlatformPackage
+ * @requires jpackage.test.SQETest == null
+ * @build jdk.jpackage.test.*
+ * @compile PerUserCfgTest.java
+ * @modules jdk.jpackage/jdk.jpackage.internal
+ * @run main/othervm/timeout=360 -Xmx512m jdk.jpackage.test.Main
+ *  --jpt-run=PerUserCfgTest
+ */
+public class PerUserCfgTest {
+
+    @Test
+    public static void test() throws IOException {
+        // Create a number of .cfg files with different startup args
+        JPackageCommand cfgCmd = JPackageCommand.helloAppImage().setFakeRuntime()
+                .setArgumentValue("--dest", TKit.createTempDirectory("cfg-files").toString());
+
+        addLauncher(cfgCmd, "a");
+        addLauncher(cfgCmd, "b");
+
+        cfgCmd.execute();
+
+        new PackageTest().configureHelloApp().addInstallVerifier(cmd -> {
+            if (cmd.isPackageUnpacked("Not running per-user configuration tests")) {
+                return;
+            }
+
+            Path launcherPath = cmd.appLauncherPath();
+            if (!cmd.canRunLauncher(String.format(
+                    "Not running %s launcher and per-user configuration tests",
+                    launcherPath))) {
+                return;
+            }
+
+            final PackageType type = cmd.packageType();
+            if (PackageType.MAC.contains(type)) {
+                withConfigFile(cmd, cfgCmd.appLauncherCfgPath("a"),
+                        getUserHomeDir().resolve("Library/Application Support").resolve(
+                                cmd.name()), theCmd -> {
+                    runMainLauncher(cmd, "a");
+                });
+            } else if (PackageType.LINUX.contains(type)) {
+                final String pkgName = LinuxHelper.getPackageName(cmd);
+                final Path homeDir = getUserHomeDir();
+
+                withConfigFile(cmd, cfgCmd.appLauncherCfgPath("a"),
+                        homeDir.resolve(".local").resolve(pkgName), theCmd -> {
+                    runMainLauncher(cmd, "a");
+                });
+
+                withConfigFile(cmd, cfgCmd.appLauncherCfgPath("b"),
+                        homeDir.resolve("." + pkgName), theCmd -> {
+                    runMainLauncher(cmd, "b");
+                });
+
+                withConfigFile(cmd, cfgCmd.appLauncherCfgPath("b"),
+                        homeDir.resolve("." + pkgName), theCmd -> {
+                    runMainLauncher(cmd, "b");
+
+                    withConfigFile(cmd, cfgCmd.appLauncherCfgPath("a"),
+                            homeDir.resolve(".local").resolve(pkgName),
+                            theCmd2 -> {
+                                runMainLauncher(cmd, "a");
+                            });
+                });
+            } else if (PackageType.WINDOWS.contains(type)) {
+                final Path appData = getDirFromEnvVariable("APPDATA");
+                final Path localAppData = getDirFromEnvVariable("LOCALAPPDATA");
+
+                if (appData == null || localAppData == null) {
+                    TKit.trace(String.format(
+                            "Not running per-user configuration tests because some of the environment varibles are not set. "
+                                    + "Run jtreg with -e:APPDATA,LOCALAPPDATA option to fix the problem"));
+                } else {
+                    withConfigFile(cmd, cfgCmd.appLauncherCfgPath("a"),
+                            appData.resolve(cmd.name()), theCmd -> {
+                        runMainLauncher(cmd, "a");
+                    });
+
+                    withConfigFile(cmd, cfgCmd.appLauncherCfgPath("b"),
+                            localAppData.resolve(cmd.name()), theCmd -> {
+                        runMainLauncher(cmd, "b");
+                    });
+
+                    withConfigFile(cmd, cfgCmd.appLauncherCfgPath("b"),
+                            appData.resolve(cmd.name()), theCmd -> {
+                        runMainLauncher(cmd, "b");
+
+                        withConfigFile(cmd, cfgCmd.appLauncherCfgPath("a"),
+                                localAppData.resolve(cmd.name()),
+                                theCmd2 -> {
+                                    runMainLauncher(cmd, "a");
+                                });
+                    });
+                }
+            }
+            runMainLauncher(cmd);
+        }).run();
+    }
+
+    private static void addLauncher(JPackageCommand cmd, String name) {
+        new AdditionalLauncher(name) {
+            @Override
+            protected void verify(JPackageCommand cmd) {}
+        }.setDefaultArguments(name).applyTo(cmd);
+    }
+
+    private static Path getUserHomeDir() {
+        return getDirFromEnvVariable("HOME");
+    }
+
+    private static Path getDirFromEnvVariable(String envVariableName) {
+        return Optional.ofNullable(System.getenv(envVariableName)).map(Path::of).orElse(
+                null);
+    }
+
+    private static void withConfigFile(JPackageCommand cmd, Path srcCfgFile,
+            Path outputCfgFileDir, ThrowingConsumer<JPackageCommand> action) throws
+            Throwable {
+        Path targetCfgFile = outputCfgFileDir.resolve(cmd.appLauncherCfgPath(
+                null).getFileName());
+        TKit.assertPathExists(targetCfgFile, false);
+        try (var dirCleaner = TKit.createDirectories(targetCfgFile.getParent())) {
+            Files.copy(srcCfgFile, targetCfgFile);
+            try {
+                TKit.traceFileContents(targetCfgFile, "cfg file");
+                action.accept(cmd);
+            } finally {
+                Files.deleteIfExists(targetCfgFile);
+            }
+        }
+    }
+
+    private static void runMainLauncher(JPackageCommand cmd,
+            String... expectedArgs) {
+
+        HelloApp.assertApp(cmd.appLauncherPath()).addDefaultArguments(List.of(
+                expectedArgs)).executeAndVerifyOutput();
+    }
+}
diff --git a/test/langtools/TEST.ROOT b/test/langtools/TEST.ROOT
index 1986a949ed2..44030ce3810 100644
--- a/test/langtools/TEST.ROOT
+++ b/test/langtools/TEST.ROOT
@@ -26,3 +26,17 @@ useNewPatchModule=true
 # Path to libraries in the topmost test directory. This is needed so @library
 # does not need ../../ notation to reach them
 external.lib.roots = ../../
+
+# Allow querying of various System properties in @requires clauses
+#
+# Source files for classes that will be used at the beginning of each test suite run,
+# to determine additional characteristics of the system for use with the @requires tag.
+# Note: compiled bootlibs classes will be added to BCP.
+requires.extraPropDefns = ../jtreg-ext/requires/VMProps.java
+requires.extraPropDefns.bootlibs = ../lib/jdk/test/whitebox
+requires.extraPropDefns.libs = \
+    ../lib/jdk/test/lib/Platform.java \
+    ../lib/jdk/test/lib/Container.java
+requires.extraPropDefns.vmOpts = -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
+requires.properties= \
+    vm.continuations
diff --git a/test/langtools/jdk/javadoc/doclet/testNewApiList/TestNewApiList.java b/test/langtools/jdk/javadoc/doclet/testNewApiList/TestNewApiList.java
index cd7278719a7..b8267947d85 100644
--- a/test/langtools/jdk/javadoc/doclet/testNewApiList/TestNewApiList.java
+++ b/test/langtools/jdk/javadoc/doclet/testNewApiList/TestNewApiList.java
@@ -23,7 +23,7 @@
 
 /*
  * @test
- * @bug      8263468 8269401 8268422
+ * @bug      8263468 8269401 8268422 8287524
  * @summary  New page for "recent" new API
  * @library  ../../lib
  * @modules  jdk.javadoc/jdk.javadoc.internal.tool
@@ -476,10 +476,10 @@ private void checkMultiReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Element</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color for-removal for-removal-tab6"><a hr\
+                <div class="col-summary-item-name even-row-color for-removal for-removal-tab1"><a hr\
                 ef="mdl/pkg/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
-                <div class="col-second even-row-color for-removal for-removal-tab6">5</div>
-                <div class="col-last even-row-color for-removal for-removal-tab6"></div>
+                <div class="col-second even-row-color for-removal for-removal-tab1">3.2</div>
+                <div class="col-last even-row-color for-removal for-removal-tab1"></div>
                 </div>""",
             """
                 <div id="method">
@@ -491,10 +491,10 @@ private void checkMultiReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Method</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color method method-tab6"><a href="mdl/pk\
+                <div class="col-summary-item-name even-row-color method method-tab1"><a href="mdl/pk\
                 g/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
-                <div class="col-second even-row-color method method-tab6">5</div>
-                <div class="col-last even-row-color method method-tab6"></div>
+                <div class="col-second even-row-color method method-tab1">3.2</div>
+                <div class="col-last even-row-color method method-tab1"></div>
                 </div>""",
             """
                 <div id="constructor">
@@ -506,10 +506,10 @@ private void checkMultiReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Constructor</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color constructor constructor-tab6"><a hr\
-                ef="mdl/pkg/TestClass.html#%3Cinit%3E()">pkg.TestClass()</a></div>
-                <div class="col-second even-row-color constructor constructor-tab6">5</div>
-                <div class="col-last even-row-color constructor constructor-tab6"></div>
+                <div class="col-summary-item-name even-row-color constructor"><a href="mdl/pkg/TestC\
+                lass.html#%3Cinit%3E()">pkg.TestClass()</a></div>
+                <div class="col-second even-row-color constructor">6</div>
+                <div class="col-last even-row-color constructor"></div>
                 </div>""",
             """
                 <div id="enum-constant">
@@ -521,10 +521,10 @@ private void checkMultiReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Enum Constant</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color enum-constant enum-constant-tab6"><\
+                <div class="col-summary-item-name even-row-color enum-constant enum-constant-tab2"><\
                 a href="mdl/pkg/TestEnum.html#DEPRECATED">pkg.TestEnum.DEPRECATED</a></div>
-                <div class="col-second even-row-color enum-constant enum-constant-tab6">5</div>
-                <div class="col-last even-row-color enum-constant enum-constant-tab6"></div>
+                <div class="col-second even-row-color enum-constant enum-constant-tab2">5</div>
+                <div class="col-last even-row-color enum-constant enum-constant-tab2"></div>
                 </div>""",
             """
                 <div id="annotation-interface-member">
@@ -537,9 +537,9 @@ private void checkMultiReleaseDeprecatedElements() {
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
                 <div class="col-summary-item-name even-row-color annotation-interface-member annotat\
-                ion-interface-member-tab6"><a href="mdl/pkg/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
-                <div class="col-second even-row-color annotation-interface-member annotation-interface-member-tab6">5</div>
-                <div class="col-last even-row-color annotation-interface-member annotation-interface-member-tab6"></div>
+                ion-interface-member-tab1"><a href="mdl/pkg/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
+                <div class="col-second even-row-color annotation-interface-member annotation-interface-member-tab1">3.2</div>
+                <div class="col-last even-row-color annotation-interface-member annotation-interface-member-tab1"></div>
                 </div>""");
     }
 
@@ -553,53 +553,46 @@ private void checkSingleReleaseContents() {
                 <li><a href="#constructor">Constructors</a></li>
                 </ul>
                 </div>
-                <div class="checkboxes">Show API added in:<label for="release-1">""");
+                <ul class="block-list">""");
     }
 
     private void checkSingleReleaseNewElements() {
         checkOutput("new-list.html", true,
                 """
-                <div class="table-tabs" role="tablist" aria-orientation="horizontal">
                 <div class="caption"><span>New Methods</span></div>
-                </div>
-                <div id="method.tabpanel" role="tabpanel">
-                <div class="summary-table three-column-release-summary" aria-labelledby="method-tab0">
+                <div class="summary-table three-column-release-summary">
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Method</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Added in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color method method-tab1"><a href="mdl/pk\
-                g/TestClass.html#overloadedMethod(java.lang.String)">pkg.TestClass.overloadedMethod<\
-                wbr>(String)</a></div>
-                <div class="col-second even-row-color method method-tab1">5</div>
-                <div class="col-last even-row-color method method-tab1">
+                <div class="col-summary-item-name even-row-color"><a href="mdl/pkg/TestClass.html#ov\
+                erloadedMethod(java.lang.String)">pkg.TestClass.overloadedMethod<wbr>(String)</a></div>
+                <div class="col-second even-row-color">5</div>
+                <div class="col-last even-row-color">
                 <div class="block">TestClass overloaded method.</div>
                 </div>
-                <div class="col-summary-item-name odd-row-color method method-tab1"><a href="mdl/pkg\
-                /TestRecord.html#x()">pkg.TestRecord.x()</a></div>
-                <div class="col-second odd-row-color method method-tab1">5</div>
-                <div class="col-last odd-row-color method method-tab1">
+                <div class="col-summary-item-name odd-row-color"><a href="mdl/pkg/TestRecord.html#x(\
+                )">pkg.TestRecord.x()</a></div>
+                <div class="col-second odd-row-color">5</div>
+                <div class="col-last odd-row-color">
                 <div class="block">Test record getter.</div>
                 </div>""",
             """
                 <div id="constructor">
-                <div class="table-tabs" role="tablist" aria-orientation="horizontal">
                 <div class="caption"><span>New Constructors</span></div>
-                </div>
-                <div id="constructor.tabpanel" role="tabpanel">
-                <div class="summary-table three-column-release-summary" aria-labelledby="constructor-tab0">
+                <div class="summary-table three-column-release-summary">
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Constructor</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Added in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color constructor constructor-tab1"><a hr\
-                ef="mdl/pkg/TestError.html#%3Cinit%3E()">pkg.TestError()</a></div>
-                <div class="col-second even-row-color constructor constructor-tab1">5</div>
-                <div class="col-last even-row-color constructor constructor-tab1">
+                <div class="col-summary-item-name even-row-color"><a href="mdl/pkg/TestError.html#%3\
+                Cinit%3E()">pkg.TestError()</a></div>
+                <div class="col-second even-row-color">5</div>
+                <div class="col-last even-row-color">
                 <div class="block">Test error constructor.</div>
                 </div>
-                <div class="col-summary-item-name odd-row-color constructor constructor-tab1"><a hre\
-                f="mdl/pkg/TestException.html#%3Cinit%3E()">pkg.TestException()</a></div>
-                <div class="col-second odd-row-color constructor constructor-tab1">5</div>
-                <div class="col-last odd-row-color constructor constructor-tab1">
+                <div class="col-summary-item-name odd-row-color"><a href="mdl/pkg/TestException.html\
+                #%3Cinit%3E()">pkg.TestException()</a></div>
+                <div class="col-second odd-row-color">5</div>
+                <div class="col-last odd-row-color">
                 <div class="block">Exception constructor.</div>
                 </div>""");
     }
@@ -628,10 +621,10 @@ private void checkSingleReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Element</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color for-removal for-removal-tab1"><a hr\
-                ef="mdl/pkg/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
-                <div class="col-second even-row-color for-removal for-removal-tab1">5</div>
-                <div class="col-last even-row-color for-removal for-removal-tab1"></div>
+                <div class="col-summary-item-name even-row-color for-removal"><a href="mdl/pkg/TestA\
+                nnotation.html#required()">pkg.TestAnnotation.required()</a></div>
+                <div class="col-second even-row-color for-removal">3.2</div>
+                <div class="col-last even-row-color for-removal"></div>
                 </div>""",
             """
                 <div id="method">
@@ -643,10 +636,10 @@ private void checkSingleReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Method</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color method method-tab1"><a href="mdl/pk\
-                g/TestAnnotation.html#required()">pkg.TestAnnotation.required()</a></div>
-                <div class="col-second even-row-color method method-tab1">5</div>
-                <div class="col-last even-row-color method method-tab1"></div>
+                <div class="col-summary-item-name even-row-color method"><a href="mdl/pkg/TestAnnota\
+                tion.html#required()">pkg.TestAnnotation.required()</a></div>
+                <div class="col-second even-row-color method">3.2</div>
+                <div class="col-last even-row-color method"></div>
                 </div>""",
             """
                 <div id="constructor">
@@ -658,10 +651,10 @@ private void checkSingleReleaseDeprecatedElements() {
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Constructor</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color constructor constructor-tab1"><a hr\
-                ef="mdl/pkg/TestClass.html#%3Cinit%3E()">pkg.TestClass()</a></div>
-                <div class="col-second even-row-color constructor constructor-tab1">5</div>
-                <div class="col-last even-row-color constructor constructor-tab1"></div>
+                <div class="col-summary-item-name even-row-color constructor"><a href="mdl/pkg/TestC\
+                lass.html#%3Cinit%3E()">pkg.TestClass()</a></div>
+                <div class="col-second even-row-color constructor">6</div>
+                <div class="col-last even-row-color constructor"></div>
                 </div>""");
     }
 
@@ -786,22 +779,19 @@ private void checkPackageDeprecatedElements() {
                 <li><a href="#constructor">Constructors</a></li>
                 </ul>
                 </div>
-                <div class="checkboxes">Show API deprecated in:<label for="release-1">
+                <ul class="block-list">
                 """,
             """
                 <div id="constructor">
-                <div class="table-tabs" role="tablist" aria-orientation="horizontal">
                 <div class="caption"><span>Deprecated Constructors</span></div>
-                </div>
-                <div id="constructor.tabpanel" role="tabpanel">
-                <div class="summary-table three-column-release-summary" aria-labelledby="constructor-tab0">
+                <div class="summary-table three-column-release-summary">
                 <div class="table-header col-first sort-asc" onclick="sortTable(this, 0, 3)">Constructor</div>
                 <div class="table-header col-second" onclick="sortTable(this, 1, 3)">Deprecated in</div>
                 <div class="table-header col-last">Description</div>
-                <div class="col-summary-item-name even-row-color constructor constructor-tab4"><a hr\
-                ef="pkg/TestClass.html#%3Cinit%3E()">pkg.TestClass()</a></div>
-                <div class="col-second even-row-color constructor constructor-tab4">5</div>
-                <div class="col-last even-row-color constructor constructor-tab4"></div>
+                <div class="col-summary-item-name even-row-color"><a href="pkg/TestClass.html#%3Cini\
+                t%3E()">pkg.TestClass()</a></div>
+                <div class="col-second even-row-color">5</div>
+                <div class="col-last even-row-color"></div>
                 </div>""");
     }
 }
diff --git a/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestAnnotation.java b/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestAnnotation.java
index 6aa2a8ada2b..15710176948 100644
--- a/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestAnnotation.java
+++ b/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestAnnotation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2022, 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
@@ -38,10 +38,10 @@
     String optional() default "unknown";
 
     /**
-     *  Required annotation interface element.
+     * Required annotation interface element.
      * @since 2.0b
      */
-    @Deprecated(forRemoval=true,since="5")
+    @Deprecated(forRemoval=true,since="3.2")
     int required();
 
     /**
diff --git a/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestClass.java b/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestClass.java
index 0a56d1bf6ae..595970b5513 100644
--- a/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestClass.java
+++ b/test/langtools/jdk/javadoc/doclet/testNewApiList/mdl/pkg/TestClass.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2022, 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
@@ -39,7 +39,7 @@ public class TestClass {
      * TestClass constructor.
      * @since 2.0b
      */
-    @Deprecated(since="5")
+    @Deprecated(since="6")
     public TestClass() {}
 
     /**
diff --git a/test/langtools/jdk/jshell/ToolEnablePreviewTest.java b/test/langtools/jdk/jshell/ToolEnablePreviewTest.java
index e61eb0b537e..ff83516c871 100644
--- a/test/langtools/jdk/jshell/ToolEnablePreviewTest.java
+++ b/test/langtools/jdk/jshell/ToolEnablePreviewTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2022, 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
@@ -25,6 +25,7 @@
  * @test
  * @bug 8199193
  * @summary Tests for the --enable-preview option
+ * @requires vm.continuations
  * @run testng ToolEnablePreviewTest
  */
 
diff --git a/test/lib/jdk/test/lib/cds/CDSArchiveUtils.java b/test/lib/jdk/test/lib/cds/CDSArchiveUtils.java
index 908b0da4531..cd5709862a1 100644
--- a/test/lib/jdk/test/lib/cds/CDSArchiveUtils.java
+++ b/test/lib/jdk/test/lib/cds/CDSArchiveUtils.java
@@ -461,6 +461,35 @@ public static File deleteBytesAtRandomPositionAfterHeader(File orgFile, String n
         return dstFile;
     }
 
+    // returns the size of the last region with used bytes > 0.
+    private static long getLastUsedRegionSize(File jsaFile) throws Exception {
+        int i = num_regions - 1;
+        long regionSize = 0;
+        while (i >= 0) {
+            regionSize = usedRegionSizeAligned(jsaFile, i);
+            if (regionSize > 0) {
+                break;
+            }
+            i--;
+        }
+        return regionSize;
+    }
+
+    // delete last regions's used bytes at the end, so new file will be smaller than the original
+    public static File deleteBytesAtTheEnd(File orgFile, String newFileName) throws Exception {
+        long offset = fileHeaderSize(orgFile);
+        long bytesToDelete = getLastUsedRegionSize(orgFile);
+        File dstFile = new File(newFileName);
+        try (FileChannel inputChannel = new FileInputStream(orgFile).getChannel();
+             FileChannel outputChannel = new FileOutputStream(dstFile).getChannel()) {
+            long orgSize = inputChannel.size();
+            transferFrom(inputChannel, outputChannel, 0, offset);
+            inputChannel.position(offset);
+            transferFrom(inputChannel, outputChannel, offset, orgSize - bytesToDelete);
+        }
+        return dstFile;
+    }
+
     // used region size
     public static long usedRegionSizeAligned(File archiveFile, int region) throws Exception {
         long offset = spOffset + cdsFileMapRegionSize * region + spUsedOffset;
diff --git a/test/lib/jdk/test/lib/util/ForceGC.java b/test/lib/jdk/test/lib/util/ForceGC.java
index 888869dc53a..1a71dd229d1 100644
--- a/test/lib/jdk/test/lib/util/ForceGC.java
+++ b/test/lib/jdk/test/lib/util/ForceGC.java
@@ -32,21 +32,24 @@
  * Utility class to invoke System.gc()
  */
 public class ForceGC {
-    private final CountDownLatch cleanerInvoked = new CountDownLatch(1);
-    private final Cleaner cleaner = Cleaner.create();
+    private final static Cleaner cleaner = Cleaner.create();
+
+    private final CountDownLatch cleanerInvoked;
     private Object o;
+    private int gcCount = 0;
 
     public ForceGC() {
         this.o = new Object();
-        cleaner.register(o, () -> cleanerInvoked.countDown());
+        this.cleanerInvoked = new CountDownLatch(1);
+        cleaner.register(o, cleanerInvoked::countDown);
     }
 
     private void doit(int iter) {
         try {
             for (int i = 0; i < 10; i++) {
                 System.gc();
-                System.out.println("doit() iter: " + iter + ", gc " + i);
-                if (cleanerInvoked.await(1L, TimeUnit.SECONDS)) {
+                gcCount++;
+                if (cleanerInvoked.await(100L, TimeUnit.MILLISECONDS)) {
                     return;
                 }
             }
@@ -68,12 +71,20 @@ public boolean await(BooleanSupplier s) {
         o = null; // Keep reference to Object until now, to ensure the Cleaner
                   // doesn't count down the latch before await() is called.
         for (int i = 0; i < 10; i++) {
-            if (s.getAsBoolean()) return true;
+            if (s.getAsBoolean()) {
+                System.out.println("ForceGC condition met after System.gc() " + gcCount + " times");
+                return true;
+            }
+
             doit(i);
-            try { Thread.sleep(1000); } catch (InterruptedException e) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
                 throw new AssertionError("unexpected interrupted sleep", e);
             }
         }
+
+        System.out.println("ForceGC condition not met after System.gc() " + gcCount + " times");
         return false;
     }
 }
diff --git a/test/micro/org/openjdk/bench/vm/compiler/VectorShiftRight.java b/test/micro/org/openjdk/bench/vm/compiler/VectorShiftRight.java
index 068d1bd704d..1edfb50bd5b 100644
--- a/test/micro/org/openjdk/bench/vm/compiler/VectorShiftRight.java
+++ b/test/micro/org/openjdk/bench/vm/compiler/VectorShiftRight.java
@@ -85,6 +85,13 @@ public void urShiftByte() {
         }
     }
 
+    @Benchmark
+    public void urShiftImmByte() {
+        for (int i = 0; i < SIZE; i++) {
+            bytesB[i] = (byte) (bytesA[i] >>> 3);
+        }
+    }
+
     @Benchmark
     public void rShiftShort() {
         for (int i = 0; i < SIZE; i++) {
@@ -92,6 +99,13 @@ public void rShiftShort() {
         }
     }
 
+    @Benchmark
+    public void urShiftImmShort() {
+        for (int i = 0; i < SIZE; i++) {
+            shortsB[i] = (short) (shortsA[i] >>> 3);
+        }
+    }
+
     @Benchmark
     public void urShiftChar() {
         for (int i = 0; i < SIZE; i++) {