--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/nio/file/etc/MacVolumesTest.java	Mon Sep 23 13:59:41 2019 -0700
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2019, 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 8231254
+ * @requires os.family == "mac"
+ * @summary Check access and basic NIO APIs on APFS for macOS version >= 10.15
+ */
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.ByteBuffer;
+import java.nio.channels.SeekableByteChannel;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.nio.file.attribute.FileTime;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Random;
+
+public class MacVolumesTest {
+    private static final String SYSTEM_VOLUME = "/";
+    private static final String DATA_VOLUME = "/System/Volumes/Data";
+    private static final String FIRMLINKS = "/usr/share/firmlinks";
+
+    private static final void checkSystemVolume() throws IOException {
+        System.out.format("--- Checking system volume %s ---%n", SYSTEM_VOLUME);
+        Path root = Path.of(SYSTEM_VOLUME);
+        if (!Files.getFileStore(root).isReadOnly()) {
+            throw new RuntimeException("Root volume is not read-only");
+        }
+
+        Path tempDir;
+        try {
+            tempDir = Files.createTempDirectory(root, "tempDir");
+            throw new RuntimeException("Created temporary directory in root");
+        } catch (IOException ignore) {
+        }
+
+        Path tempFile;
+        try {
+            tempFile = Files.createTempFile(root, "tempFile", null);
+            throw new RuntimeException("Created temporary file in root");
+        } catch (IOException ignore) {
+        }
+
+        Path path = null;
+        Path etc = Path.of(SYSTEM_VOLUME, "etc");
+        if (Files.isWritable(etc)) {
+            throw new RuntimeException("System path " + etc + " is writable");
+        }
+        try (DirectoryStream<Path> ds = Files.newDirectoryStream(etc)) {
+            Iterator<Path> paths = ds.iterator();
+            while (paths.hasNext()) {
+                Path p = paths.next();
+                if (Files.isReadable(p) && Files.isRegularFile(p)) {
+                    path = p;
+                    break;
+                }
+            }
+        }
+        if (path == null) {
+            System.err.println("No root test file found: skipping file test");
+            return;
+        }
+        System.out.format("Using root test file %s%n", path);
+
+        if (Files.isWritable(path)) {
+            throw new RuntimeException("Test file " + path + " is writable");
+        }
+
+        FileTime creationTime =
+            (FileTime)Files.getAttribute(path, "basic:creationTime");
+        System.out.format("%s creation time: %s%n", path, creationTime);
+
+        long size = Files.size(path);
+        int capacity = (int)Math.min(1024, size);
+        ByteBuffer buf = ByteBuffer.allocate(capacity);
+        try (SeekableByteChannel sbc = Files.newByteChannel(path)) {
+            int n = sbc.read(buf);
+            System.out.format("Read %d bytes from %s%n", n, path);
+        }
+    }
+
+    private static final void checkDataVolume() throws IOException {
+        System.out.format("--- Checking data volume %s ---%n", DATA_VOLUME);
+        Path data = Path.of(DATA_VOLUME, "tmp");
+        if (Files.getFileStore(data).isReadOnly()) {
+            throw new RuntimeException("Data volume is read-only");
+        }
+
+        Path tempDir = Files.createTempDirectory(data, "tempDir");
+        tempDir.toFile().deleteOnExit();
+        System.out.format("Temporary directory: %s%n", tempDir);
+        if (!Files.isWritable(tempDir)) {
+            throw new RuntimeException("Temporary directory is not writable");
+        }
+
+        Path tempFile = Files.createTempFile(tempDir, "tempFile", null);
+        tempFile.toFile().deleteOnExit();
+        System.out.format("Temporary file: %s%n", tempFile);
+        if (!Files.isWritable(tempFile)) {
+            throw new RuntimeException("Temporary file is not writable");
+        }
+
+        byte[] bytes = new byte[42];
+        new Random().nextBytes(bytes);
+        try (SeekableByteChannel sbc = Files.newByteChannel(tempFile,
+            StandardOpenOption.WRITE)) {
+            ByteBuffer src = ByteBuffer.wrap(bytes);
+            if (sbc.write(src) != bytes.length) {
+                throw new RuntimeException("Incorrect number of bytes written");
+            }
+        }
+
+        try (SeekableByteChannel sbc = Files.newByteChannel(tempFile)) {
+            ByteBuffer dst = ByteBuffer.allocate(bytes.length);
+            if (sbc.read(dst) != bytes.length) {
+                throw new RuntimeException("Incorrect number of bytes read");
+            }
+            if (!Arrays.equals(dst.array(), bytes)) {
+                throw new RuntimeException("Bytes read != bytes written");
+            }
+        }
+    }
+
+    static void checkFirmlinks() throws IOException {
+        System.out.format("--- Checking firmlinks %s ---%n", FIRMLINKS);
+        Path firmlinks = Path.of(FIRMLINKS);
+        if (!Files.exists(firmlinks)) {
+            System.err.format("%s does not exist: skipping firmlinks test%n",
+                firmlinks);
+            return;
+        } else if (!Files.isReadable(firmlinks)) {
+            throw new RuntimeException(String.format("%s is not readable",
+                firmlinks));
+        }
+
+        try (BufferedReader br = Files.newBufferedReader(firmlinks)) {
+            String line;
+            while ((line = br.readLine()) != null) {
+                String file = line.split("\\s")[0];
+                Path path = Path.of(file);
+                if (!Files.exists(path)) {
+                    System.err.format("Firmlink %s does not exist: skipping%n",
+                        file);
+                    continue;
+                }
+                if (Files.getFileStore(path).isReadOnly()) {
+                    String msg = String.format("%s is read-only%n", file);
+                    throw new RuntimeException(msg);
+                } else {
+                    System.out.format("Firmlink %s OK%n", file);
+                }
+            }
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        String[] osv = System.getProperty("os.version").split("\\.");
+        int major = Integer.valueOf(osv[0]);
+        int minor = Integer.valueOf(osv[1]);
+        if (major < 10 || (major == 10 && minor < 15)) {
+            System.out.format("macOS version %d.%d too old: skipping test%n",
+                major, minor);
+            return;
+        }
+
+        // Check system volume for read-only.
+        checkSystemVolume();
+
+        // Check data volume for read-write.
+        checkDataVolume();
+
+        // Check firmlinks for read-write.
+        checkFirmlinks();
+    }
+}