/**

public static final String TEST_CLASS_PATH = System.getProperty("test.class.path", ".");

/**

public static final String NEW_LINE = System.getProperty("line.separator");

/**

public static final String VM_OPTIONS = System.getProperty("test.vm.opts", "").trim();

/**

public static final String JAVA_OPTIONS = System.getProperty("test.java.opts", "").trim();

/**

public static final String TEST_SRC = System.getProperty("test.src", "").trim();

/**

public static final String TEST_ROOT = System.getProperty("test.root", "").trim();

/*

public static final String TEST_JDK = System.getProperty("test.jdk");

/*

public static final String COMPILE_JDK = System.getProperty("compile.jdk", TEST_JDK);

/**

public static final String TEST_CLASSES = System.getProperty("test.classes", ".");

/**

public static final String TEST_NAME = System.getProperty("test.name", ".");

/**

public static final String TEST_NATIVE_PATH = System.getProperty("test.nativepath", ".");

/**

public static final String SEED_PROPERTY_NAME = "jdk.test.lib.random.seed";

/**

public static final String FILE_SEPARATOR = System.getProperty("file.separator");

/**

private static volatile Random RANDOM_GENERATOR;

/**

private static final int MAX_SOCKET_TRIES = 10;

/**

public static final long SEED;

static {

var seed = Long.getLong(SEED_PROPERTY_NAME);

if (seed != null) {

// use explicitly set seed

SEED = seed;

} else {

var v = Runtime.version();

// promotable builds have build number, and it's greater than 0

if (v.build().orElse(0) > 0) {

// promotable build -> use 1st 8 bytes of md5($version)

try {

var md = MessageDigest.getInstance("MD5");

var bytes = v.toString()

.getBytes(StandardCharsets.UTF_8);

bytes = md.digest(bytes);

SEED = ByteBuffer.wrap(bytes).getLong();

} catch (NoSuchAlgorithmException e) {

throw new Error(e);

}

} else {

// "personal" build -> use random seed

SEED = new Random().nextLong();

}

}

}

/**

public static final double TIMEOUT_FACTOR;

static {

String toFactor = System.getProperty("test.timeout.factor", "1.0");

TIMEOUT_FACTOR = Double.parseDouble(toFactor);

}

/**

public static final long DEFAULT_TEST_TIMEOUT = TimeUnit.SECONDS.toMillis(120);

private Utils() {

// Private constructor to prevent class instantiation

}

/**

public static List<String> getForwardVmOptions() {

String[] opts = safeSplitString(VM_OPTIONS);

for (int i = 0; i < opts.length; i++) {

opts[i] = "-J" + opts[i];

}

return Arrays.asList(opts);

}

/**

public static String[] getTestJavaOpts() {

List<String> opts = new ArrayList<String>();

Collections.addAll(opts, safeSplitString(VM_OPTIONS));

Collections.addAll(opts, safeSplitString(JAVA_OPTIONS));

return opts.toArray(new String[0]);

}

/**

public static String[] prependTestJavaOpts(String... userArgs) {

List<String> opts = new ArrayList<String>();

Collections.addAll(opts, getTestJavaOpts());

Collections.addAll(opts, userArgs);

return opts.toArray(new String[0]);

}

/**

public static String[] appendTestJavaOpts(String... userArgs) {

List<String> opts = new ArrayList<String>();

Collections.addAll(opts, userArgs);

Collections.addAll(opts, getTestJavaOpts());

return opts.toArray(new String[0]);

}

/**

public static String[] addTestJavaOpts(String... userArgs) {

return prependTestJavaOpts(userArgs);

}

private static final Pattern useGcPattern = Pattern.compile(

"(?:\\-XX\\:[\\+\\-]Use.+GC)");

/**

public static List<String> removeGcOpts(List<String> opts) {

List<String> optsWithoutGC = new ArrayList<String>();

for (String opt : opts) {

if (useGcPattern.matcher(opt).matches()) {

System.out.println("removeGcOpts: removed " + opt);

} else {

optsWithoutGC.add(opt);

}

}

return optsWithoutGC;

}

/**

public static String[] getFilteredTestJavaOpts(String... filters) {

String options[] = getTestJavaOpts();

if (filters.length == 0) {

return options;

}

List<String> filteredOptions = new ArrayList<String>(options.length);

Pattern patterns[] = new Pattern[filters.length];

for (int i = 0; i < filters.length; i++) {

patterns[i] = Pattern.compile(filters[i]);

}

for (String option : options) {

boolean matched = false;

for (int i = 0; i < patterns.length && !matched; i++) {

Matcher matcher = patterns[i].matcher(option);

matched = matcher.find();

}

if (!matched) {

filteredOptions.add(option);

}

}

return filteredOptions.toArray(new String[filteredOptions.size()]);

}

/**

private static String[] safeSplitString(String s) {

if (s == null || s.trim().isEmpty()) {

return new String[] {};

}

return s.trim().split("\\s+");

}

/**

public static String getCommandLine(ProcessBuilder pb) {

StringBuilder cmd = new StringBuilder();

for (String s : pb.command()) {

cmd.append(s).append(" ");

}

return cmd.toString();

}

/**

public static InetSocketAddress refusingEndpoint() {

InetAddress lb = InetAddress.getLoopbackAddress();

int port = 1;

while (port < 1024) {

InetSocketAddress sa = new InetSocketAddress(lb, port);

try {

SocketChannel.open(sa).close();

} catch (IOException ioe) {

return sa;

}

port++;

}

throw new RuntimeException("Unable to find system port that is refusing connections");

}

/**

public static List<InetAddress> getAddressesWithSymbolicAndNumericScopes() {

List<InetAddress> result = new LinkedList<>();

try {

NetworkConfiguration conf = NetworkConfiguration.probe();

conf.ip4Addresses().forEach(result::add);

// Java reports link local addresses with symbolic scope,

// but on Windows java.net.NetworkInterface generates its own scope names

// which are incompatible with native Windows routines.

// So on Windows test only addresses with numeric scope.

// On other platforms test both symbolic and numeric scopes.

conf.ip6Addresses()

// test only IPv6 loopback and link-local addresses (JDK-8224775)

.filter(addr -> addr.isLinkLocalAddress() || addr.isLoopbackAddress())

.forEach(addr6 -> {

try {

result.add(Inet6Address.getByAddress(null, addr6.getAddress(), addr6.getScopeId()));

} catch (UnknownHostException e) {

// cannot happen!

throw new RuntimeException("Unexpected", e);

}

if (!Platform.isWindows()) {

result.add(addr6);

}

});

} catch (IOException e) {

// cannot happen!

throw new RuntimeException("Unexpected", e);

}

return result;

}

/**

public static int getFreePort() throws IOException {

try (ServerSocket serverSocket =

new ServerSocket(0, 5, InetAddress.getLoopbackAddress());) {

return serverSocket.getLocalPort();

}

}

/**

public static int findUnreservedFreePort(int... reservedPorts) {

int numTries = 0;

while (numTries++ < MAX_SOCKET_TRIES) {

int port = -1;

try {

port = getFreePort();

} catch (IOException e) {

e.printStackTrace();

}

if (port > 0 && !isReserved(port, reservedPorts)) {

return port;

}

}

return -1;

}

private static boolean isReserved(int port, int[] reservedPorts) {

for (int p : reservedPorts) {

if (p == port) {

return true;

}

}

return false;

}

/**

public static String getHostname() throws UnknownHostException {

InetAddress inetAddress = InetAddress.getLocalHost();

String hostName = inetAddress.getHostName();

assertTrue((hostName != null && !hostName.isEmpty()),

"Cannot get hostname");

return hostName;

}

/**

public static long adjustTimeout(long tOut) {

return Math.round(tOut * Utils.TIMEOUT_FACTOR);

}

/**

public static String fileAsString(String filename) throws IOException {

Path filePath = Paths.get(filename);

if (!Files.exists(filePath)) return null;

return new String(Files.readAllBytes(filePath));

}

/**

@Deprecated

public static String toHexString(byte[] bytes) {

return HexFormat.ofDelimiter(" ").withUpperCase().formatHex(bytes);

}

/**

public static byte[] toByteArray(String hex) {

return HexFormat.of().parseHex(hex);

}

/**

public static Random getRandomInstance() {

if (RANDOM_GENERATOR == null) {

synchronized (Utils.class) {

if (RANDOM_GENERATOR == null) {

RANDOM_GENERATOR = new Random(SEED);

} else {

return RANDOM_GENERATOR;

}

}

System.out.printf("For random generator using seed: %d%n", SEED);

System.out.printf("To re-run test with same seed value please add \"-D%s=%d\" to command line.%n", SEED_PROPERTY_NAME, SEED);

}

return RANDOM_GENERATOR;

}

/**

public static <T> T getRandomElement(Collection<T> collection)

throws IllegalArgumentException {

if (collection.isEmpty()) {

throw new IllegalArgumentException("Empty collection");

}

Random random = getRandomInstance();

int elementIndex = 1 + random.nextInt(collection.size() - 1);

Iterator<T> iterator = collection.iterator();

while (--elementIndex != 0) {

iterator.next();

}

return iterator.next();

}

/**

public static <T> T getRandomElement(T[] array)

throws IllegalArgumentException {

if (array == null || array.length == 0) {

throw new IllegalArgumentException("Empty or null array");

}

Random random = getRandomInstance();

return array[random.nextInt(array.length)];

}

/**

public static final void waitForCondition(BooleanSupplier condition) {

waitForCondition(condition, -1L, 100L);

}

/**

public static final boolean waitForCondition(BooleanSupplier condition,

long timeout) {

return waitForCondition(condition, timeout, 100L);

}

/**

public static final boolean waitForCondition(BooleanSupplier condition,

long timeout, long sleepTime) {

long startTime = System.currentTimeMillis();

while (!(condition.getAsBoolean() || (timeout != -1L

&& ((System.currentTimeMillis() - startTime) > timeout)))) {

try {

Thread.sleep(sleepTime);

} catch (InterruptedException e) {

Thread.currentThread().interrupt();

throw new Error(e);

}

}

return condition.getAsBoolean();

}

/**

public static interface ThrowingRunnable {

void run() throws Throwable;

}

/**

public static Throwable filterException(ThrowingRunnable test,

Function<Throwable, Boolean> filter) throws Throwable {

try {

test.run();

} catch (Throwable t) {

if (filter.apply(t)) {

return t;

} else {

throw t;

}

}

return null;

}

/**

public static void ensureClassIsLoaded(Class<?> aClass) {

if (aClass == null) {

throw new Error("Requested null class");

}

try {

Class.forName(aClass.getName(), /* initialize = */ true,

ClassLoader.getSystemClassLoader());

} catch (ClassNotFoundException e) {

throw new Error("Class not found", e);

}

}

/**

public static URLClassLoader getTestClassPathURLClassLoader(ClassLoader parent) {

URL[] urls = Arrays.stream(TEST_CLASS_PATH.split(File.pathSeparator))

.map(Paths::get)

.map(Path::toUri)

.map(x -> {

try {

return x.toURL();

} catch (MalformedURLException ex) {

throw new Error("Test issue. JTREG property"

+ " 'test.class.path'"

+ " is not defined correctly", ex);

}

}).toArray(URL[]::new);

return new URLClassLoader(urls, parent);

}

/**

public static void runAndCheckException(ThrowingRunnable runnable, Class<? extends Throwable> expectedException) {

runAndCheckException(runnable, t -> {

if (t == null) {

if (expectedException != null) {

throw new AssertionError("Didn't get expected exception " + expectedException.getSimpleName());

}

} else {

String message = "Got unexpected exception " + t.getClass().getSimpleName();

if (expectedException == null) {

throw new AssertionError(message, t);

} else if (!expectedException.isAssignableFrom(t.getClass())) {

message += " instead of " + expectedException.getSimpleName();

throw new AssertionError(message, t);

}

}

});

}

/**

public static void runAndCheckException(ThrowingRunnable runnable, Consumer<Throwable> checkException) {

Throwable throwable = null;

try {

runnable.run();

} catch (Throwable t) {

throwable = t;

}

checkException.accept(throwable);

}

/**

public static String toJVMTypeSignature(Class<?> type) {

if (type.isPrimitive()) {

if (type == boolean.class) {

return "Z";

} else if (type == byte.class) {

return "B";

} else if (type == char.class) {

return "C";

} else if (type == double.class) {

return "D";

} else if (type == float.class) {

return "F";

} else if (type == int.class) {

return "I";

} else if (type == long.class) {

return "J";

} else if (type == short.class) {

return "S";

} else if (type == void.class) {

return "V";

} else {

throw new Error("Unsupported type: " + type);

}

}

String result = type.getName().replaceAll("\\.", "/");

if (!type.isArray()) {

return "L" + result + ";";

}

return result;

}

public static Object[] getNullValues(Class<?>... types) {

Object[] result = new Object[types.length];

int i = 0;

for (Class<?> type : types) {

result[i++] = NULL_VALUES.get(type);

}

return result;

}

private static Map<Class<?>, Object> NULL_VALUES = new HashMap<>();

static {

NULL_VALUES.put(boolean.class, false);

NULL_VALUES.put(byte.class, (byte) 0);

NULL_VALUES.put(short.class, (short) 0);

NULL_VALUES.put(char.class, '\0');

NULL_VALUES.put(int.class, 0);

NULL_VALUES.put(long.class, 0L);

NULL_VALUES.put(float.class, 0.0f);

NULL_VALUES.put(double.class, 0.0d);

}

/*

public static OutputAnalyzer uname(String... args) throws Throwable {

String[] cmds = new String[args.length + 1];

cmds[0] = "uname";

System.arraycopy(args, 0, cmds, 1, args.length);

return ProcessTools.executeCommand(cmds);

}

/**

public static Path createTempFile(String prefix, String suffix, FileAttribute<?>... attrs) throws IOException {

Path dir = Paths.get(System.getProperty("user.dir", "."));

return Files.createTempFile(dir, prefix, suffix, attrs);

}

/**

public static Path createTempDirectory(String prefix, FileAttribute<?>... attrs) throws IOException {

Path dir = Paths.get(System.getProperty("user.dir", "."));

return Files.createTempDirectory(dir, prefix, attrs);

}

/**

public static String convertPath(String path) {

// No need to do the conversion if file separator is '/'

if (FILE_SEPARATOR.length() == 1 && FILE_SEPARATOR.charAt(0) == '/') {

return path;

}

char[] cs = path.toCharArray();

for (int i = 0; i < cs.length; i++) {

if (cs[i] == '/') {

cs[i] = '\\';

}

}

String newPath = new String(cs);

return newPath;

}

/**

public static List<Path> findFiles(Path searchDirectory,

FilenameFilter filter) {

return Arrays.stream(searchDirectory.toFile().listFiles(filter))

.map(f -> f.toPath())

.collect(Collectors.toList());

}

/**

public static List<Path> copyFiles(List<Path> source, Path target,

Function<String, String> filenameMapper,

CopyOption... options) throws IOException {

List<Path> result = new ArrayList<>();

if (!target.toFile().exists()) {

Files.createDirectory(target);

}

for (Path file : source) {

if (!file.toFile().exists()) {

continue;

}

String baseName = file.getFileName().toString();

Path targetFile = target.resolve(filenameMapper.apply(baseName));

Files.copy(file, targetFile, options);

result.add(targetFile);

}

return result;

}

/**

public static List<Path> copyFiles(List<Path> source, Path target,

CopyOption... options) throws IOException {

return copyFiles(source, target, (s) -> s, options);

}

/**

public static void replaceFileString(Path source,

Function<String, String> contentMapper) throws IOException {

StringBuilder sb = new StringBuilder();

String lineSep = System.getProperty("line.separator");

try (BufferedReader reader =

new BufferedReader(new FileReader(source.toFile()))) {

String line;

// read all and replace all at once??

while ((line = reader.readLine()) != null) {

sb.append(contentMapper.apply(line))

.append(lineSep);

}

}

try (FileWriter writer = new FileWriter(source.toFile())) {

writer.write(sb.toString());

}

}

/**

public static void replaceFilesString(List<Path> source,

Function<String, String> contentMapper) throws IOException {

for (Path file : source) {

replaceFileString(file, contentMapper);

}

}

/**

public static void grantFileAccess(Path file, boolean userOnly)

throws IOException {

Set<String> attr = file.getFileSystem().supportedFileAttributeViews();

if (attr.contains("posix")) {

String perms = userOnly ? "rwx------" : "rwxrwxrwx";

Files.setPosixFilePermissions(file, PosixFilePermissions.fromString(perms));

} else if (attr.contains("acl")) {

AclFileAttributeView view =

Files.getFileAttributeView(file, AclFileAttributeView.class);

List<AclEntry> acl = new ArrayList<>();

for (AclEntry thisEntry : view.getAcl()) {

if (userOnly) {

if (thisEntry.principal().getName()

.equals(view.getOwner().getName())) {

acl.add(allowAccess(thisEntry));

} else if (thisEntry.type() == AclEntryType.ALLOW) {

acl.add(revokeAccess(thisEntry));

} else {

acl.add(thisEntry);

}

} else {

if (thisEntry.type() != AclEntryType.ALLOW) {

acl.add(allowAccess(thisEntry));

} else {

acl.add(thisEntry);

}

}

}

view.setAcl(acl);

} else {

throw new RuntimeException("Unsupported file attributes: " + attr);

}