Extract NativeLibraryPermissionSetter from LlamaLoader

Replace the static setNativeLibraryPermissions helper with a small
NativeLibraryPermissionSetter class instantiated once per LlamaLoader.
The PrintStream warning sink is injected via constructor; apply(File)
is an instance method, so no static logic remains. Tests move to a
dedicated NativeLibraryPermissionSetterTest covering all-success,
each-setter-fails, all-fail, and null-sink rejection paths.

Author: claude

src/main/java/net/ladenthin/llama/LlamaLoader.java

@@ -9,7 +9,6 @@
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.PrintStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -36,6 +35,8 @@ class LlamaLoader {
 
 	private static boolean extracted = false;
 	private static final LlamaSystemProperties systemProperties = new LlamaSystemProperties();
+	private static final NativeLibraryPermissionSetter permissionSetter =
+			new NativeLibraryPermissionSetter(System.err);
 
 	/**
 	 * Loads the llama and jllama shared libraries
@@ -192,7 +193,7 @@ private static Path extractFile(String sourceDirectory, String fileName, String
 			}
 
 			// Set executable (x) flag to enable Java to load the native library
-			setNativeLibraryPermissions(extractedFilePath.toFile(), System.err);
+			permissionSetter.apply(extractedFilePath.toFile());
 
 			// Check whether the contents are properly copied from the resource folder
 			try (InputStream nativeIn = LlamaLoader.class.getResourceAsStream(nativeLibraryFilePath);
@@ -211,32 +212,6 @@ private static Path extractFile(String sourceDirectory, String fileName, String
 		}
 	}
 
-	/**
-	 * Sets read, write (owner-only), and execute permissions on the given file so the JVM
-	 * can load it as a native library. Returns {@code false} and writes a warning to
-	 * {@code err} if any of the permission changes were rejected by the platform.
-	 *
-	 * <p>Package-private and parameterised on {@code File}/{@code PrintStream} to keep the
-	 * branch unit-testable.
-	 *
-	 * @param file the extracted native library file
-	 * @param err  stream to receive a warning when a permission change fails
-	 * @return {@code true} if all three permission changes succeeded
-	 */
-	static boolean setNativeLibraryPermissions(File file, PrintStream err) {
-		boolean readable = file.setReadable(true);
-		boolean writable = file.setWritable(true, true);
-		boolean executable = file.setExecutable(true);
-		if (!readable || !writable || !executable) {
-			err.println("Warning: could not set permissions on " + file
-					+ " (readable=" + readable
-					+ ", writable=" + writable
-					+ ", executable=" + executable + ")");
-			return false;
-		}
-		return true;
-	}
-
 	/**
 	 * Extracts and loads the specified library file to the target folder
 	 *

src/main/java/net/ladenthin/llama/NativeLibraryPermissionSetter.java

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2026 Bernard Ladenthin <bernard.ladenthin@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+package net.ladenthin.llama;
+
+import java.io.File;
+import java.io.PrintStream;
+import java.util.Objects;
+
+/**
+ * Applies the read / write (owner-only) / execute permissions required for the
+ * JVM to load an extracted native library file.
+ *
+ * <p>The three {@link File} setter calls each return a {@code boolean}; this
+ * class observes those return values and writes a descriptive warning to a
+ * configurable {@link PrintStream} when any permission change is rejected by
+ * the platform. Both the warning sink and the entry point are instance members
+ * so the behaviour can be unit-tested without touching {@link System#err}.
+ */
+final class NativeLibraryPermissionSetter {
+
+	private final PrintStream warningSink;
+
+	NativeLibraryPermissionSetter(PrintStream warningSink) {
+		this.warningSink = Objects.requireNonNull(warningSink, "warningSink");
+	}
+
+	/**
+	 * Sets read, owner-only write, and execute permissions on {@code file}.
+	 *
+	 * @param file the extracted native library file
+	 * @return {@code true} if all three permission changes succeeded
+	 */
+	boolean apply(File file) {
+		boolean readable = file.setReadable(true);
+		boolean writable = file.setWritable(true, true);
+		boolean executable = file.setExecutable(true);
+		if (!readable || !writable || !executable) {
+			warningSink.println("Warning: could not set permissions on " + file
+					+ " (readable=" + readable
+					+ ", writable=" + writable
+					+ ", executable=" + executable + ")");
+			return false;
+		}
+		return true;
+	}
+}

src/test/java/net/ladenthin/llama/LlamaLoaderTest.java

@@ -7,11 +7,9 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.BufferedInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.PrintStream;
 import java.nio.file.Paths;
 
 import org.junit.After;
@@ -25,10 +23,8 @@
                   "native library: shouldCleanPath detects jllama/llama-prefixed files for " +
                   "cleanup; contentsEquals performs a correct byte-level stream comparison " +
                   "including BufferedInputStream wrapping and length mismatches; getTempDir " +
-                  "honours the 'net.ladenthin.llama.tmpdir' system-property override; " +
-                  "getNativeResourcePath produces the expected classpath resource prefix; and " +
-                  "setNativeLibraryPermissions returns the AND of its three File setter calls " +
-                  "and emits a descriptive warning to the given PrintStream when any fails."
+                  "honours the 'net.ladenthin.llama.tmpdir' system-property override; and " +
+                  "getNativeResourcePath produces the expected classpath resource prefix."
 )
 public class LlamaLoaderTest {
 
@@ -210,87 +206,4 @@ public void testGetNativeResourcePathContainsOsAndArch() {
 		assertTrue("Resource path should end with OS/arch: " + path,
 				path.endsWith(osArch));
 	}
-
-	// -------------------------------------------------------------------------
-	// setNativeLibraryPermissions
-	// -------------------------------------------------------------------------
-
-	/** Stub File whose setReadable/setWritable/setExecutable returns are configurable. */
-	private static class StubFile extends File {
-		final boolean readable;
-		final boolean writable;
-		final boolean executable;
-
-		StubFile(boolean readable, boolean writable, boolean executable) {
-			super("stub-native-lib");
-			this.readable = readable;
-			this.writable = writable;
-			this.executable = executable;
-		}
-
-		@Override
-		public boolean setReadable(boolean r) { return readable; }
-
-		@Override
-		public boolean setWritable(boolean w, boolean ownerOnly) { return writable; }
-
-		@Override
-		public boolean setExecutable(boolean x) { return executable; }
-	}
-
-	private static PrintStream capture(ByteArrayOutputStream sink) {
-		return new PrintStream(sink);
-	}
-
-	@Test
-	public void testSetNativeLibraryPermissionsAllSucceed() {
-		ByteArrayOutputStream sink = new ByteArrayOutputStream();
-		boolean ok = LlamaLoader.setNativeLibraryPermissions(
-				new StubFile(true, true, true), capture(sink));
-		assertTrue("expected success when all setters return true", ok);
-		assertEquals("no warning expected on success", "", sink.toString());
-	}
-
-	@Test
-	public void testSetNativeLibraryPermissionsReadableFails() {
-		ByteArrayOutputStream sink = new ByteArrayOutputStream();
-		boolean ok = LlamaLoader.setNativeLibraryPermissions(
-				new StubFile(false, true, true), capture(sink));
-		assertFalse(ok);
-		String out = sink.toString();
-		assertTrue("warning should mention readable=false: " + out, out.contains("readable=false"));
-		assertTrue("warning should mention writable=true: " + out, out.contains("writable=true"));
-		assertTrue("warning should mention executable=true: " + out, out.contains("executable=true"));
-		assertTrue("warning should mention file path: " + out, out.contains("stub-native-lib"));
-	}
-
-	@Test
-	public void testSetNativeLibraryPermissionsWritableFails() {
-		ByteArrayOutputStream sink = new ByteArrayOutputStream();
-		boolean ok = LlamaLoader.setNativeLibraryPermissions(
-				new StubFile(true, false, true), capture(sink));
-		assertFalse(ok);
-		assertTrue(sink.toString().contains("writable=false"));
-	}
-
-	@Test
-	public void testSetNativeLibraryPermissionsExecutableFails() {
-		ByteArrayOutputStream sink = new ByteArrayOutputStream();
-		boolean ok = LlamaLoader.setNativeLibraryPermissions(
-				new StubFile(true, true, false), capture(sink));
-		assertFalse(ok);
-		assertTrue(sink.toString().contains("executable=false"));
-	}
-
-	@Test
-	public void testSetNativeLibraryPermissionsAllFail() {
-		ByteArrayOutputStream sink = new ByteArrayOutputStream();
-		boolean ok = LlamaLoader.setNativeLibraryPermissions(
-				new StubFile(false, false, false), capture(sink));
-		assertFalse(ok);
-		String out = sink.toString();
-		assertTrue(out.contains("readable=false"));
-		assertTrue(out.contains("writable=false"));
-		assertTrue(out.contains("executable=false"));
-	}
 }

src/test/java/net/ladenthin/llama/NativeLibraryPermissionSetterTest.java

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: 2026 Bernard Ladenthin <bernard.ladenthin@gmail.com>
+//
+// SPDX-License-Identifier: MIT
+
+package net.ladenthin.llama;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.PrintStream;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+@ClaudeGenerated(
+		purpose = "Verify NativeLibraryPermissionSetter.apply(File): returns the AND of " +
+				"the three File setter calls (setReadable, setWritable, setExecutable) and " +
+				"emits a descriptive warning to the injected PrintStream when any setter " +
+				"returns false. Uses a StubFile subclass so the test does not touch disk."
+)
+public class NativeLibraryPermissionSetterTest {
+
+	/** Stub File whose setReadable/setWritable/setExecutable returns are configurable. */
+	private static class StubFile extends File {
+		final boolean readable;
+		final boolean writable;
+		final boolean executable;
+
+		StubFile(boolean readable, boolean writable, boolean executable) {
+			super("stub-native-lib");
+			this.readable = readable;
+			this.writable = writable;
+			this.executable = executable;
+		}
+
+		@Override
+		public boolean setReadable(boolean r) {
+			return readable;
+		}
+
+		@Override
+		public boolean setWritable(boolean w, boolean ownerOnly) {
+			return writable;
+		}
+
+		@Override
+		public boolean setExecutable(boolean x) {
+			return executable;
+		}
+	}
+
+	private ByteArrayOutputStream sink;
+	private NativeLibraryPermissionSetter setter;
+
+	private void setUp() {
+		sink = new ByteArrayOutputStream();
+		setter = new NativeLibraryPermissionSetter(new PrintStream(sink));
+	}
+
+	@Test
+	public void testApplyAllSucceed() {
+		setUp();
+		assertTrue("expected success when all setters return true",
+				setter.apply(new StubFile(true, true, true)));
+		assertEquals("no warning expected on success", "", sink.toString());
+	}
+
+	@Test
+	public void testApplyReadableFails() {
+		setUp();
+		assertFalse(setter.apply(new StubFile(false, true, true)));
+		String out = sink.toString();
+		assertTrue("warning should mention readable=false: " + out, out.contains("readable=false"));
+		assertTrue("warning should mention writable=true: " + out, out.contains("writable=true"));
+		assertTrue("warning should mention executable=true: " + out, out.contains("executable=true"));
+		assertTrue("warning should mention file path: " + out, out.contains("stub-native-lib"));
+	}
+
+	@Test
+	public void testApplyWritableFails() {
+		setUp();
+		assertFalse(setter.apply(new StubFile(true, false, true)));
+		assertTrue(sink.toString().contains("writable=false"));
+	}
+
+	@Test
+	public void testApplyExecutableFails() {
+		setUp();
+		assertFalse(setter.apply(new StubFile(true, true, false)));
+		assertTrue(sink.toString().contains("executable=false"));
+	}
+
+	@Test
+	public void testApplyAllFail() {
+		setUp();
+		assertFalse(setter.apply(new StubFile(false, false, false)));
+		String out = sink.toString();
+		assertTrue(out.contains("readable=false"));
+		assertTrue(out.contains("writable=false"));
+		assertTrue(out.contains("executable=false"));
+	}
+
+	@Test(expected = NullPointerException.class)
+	public void testConstructorRejectsNullSink() {
+		new NativeLibraryPermissionSetter(null);
+	}
+}