# HG changeset patch # User bpb # Date 1569272381 25200 # Node ID 1e57d3774190a452d2a2f466a64bf80541b68296 # Parent 2dedeaa537a26cbf1ba973770e47229cf6db268a 8231254: (fs) Add test for macOS Catalina changes to protect system software Reviewed-by: alanb diff -r 2dedeaa537a2 -r 1e57d3774190 test/jdk/java/nio/file/etc/MacVolumesTest.java --- /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 ds = Files.newDirectoryStream(etc)) { + Iterator 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(); + } +}