test: cover NativeLibrary platform mapping across all branches

Extract a pure, package-private classifier(osName, osArch) from the
system-property-reading classifier() and open up libExtension, so the
platform-mapping logic can be unit-tested with injected os.name / os.arch
instead of only the CI host's values. Adds branch coverage for the osx /
windows / linux and arch-alias paths that never run on a single platform,
plus the unsupported-arch failure. Also pins toLowerCase to Locale.ROOT.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

zstd/src/main/java/io/github/dfa1/zstd/NativeLibrary.java

@@ -13,6 +13,7 @@
 import java.nio.file.StandardCopyOption;
 import java.nio.file.attribute.FileAttribute;
 import java.nio.file.attribute.PosixFilePermissions;
+import java.util.Locale;
 
 /// Infrastructure — loads the bundled `libzstd` shared library and binds
 /// native symbols to {@link MethodHandle}s via the Foreign Function & Memory API.
@@ -74,7 +75,7 @@ private static FileAttribute<?>[] ownerOnlyAttributes() {
         return new FileAttribute<?>[0];
     }
 
-    private static String libExtension(String classifier) {
+    static String libExtension(String classifier) {
         if (classifier.startsWith("osx")) {
             return "dylib";
         }
@@ -85,27 +86,39 @@ private static String libExtension(String classifier) {
     }
 
     private static String classifier() {
-        String os = System.getProperty("os.name", "").toLowerCase();
-        String arch = System.getProperty("os.arch", "").toLowerCase();
-        String osName;
+        return classifier(System.getProperty("os.name", ""), System.getProperty("os.arch", ""));
+    }
+
+    /// Maps a JVM `os.name` / `os.arch` pair to a native-jar classifier
+    /// (`<os>-<arch>`). A pure function of its inputs so it can be unit-tested
+    /// across platforms without touching the real system properties.
+    ///
+    /// @param osName  the raw `os.name` value (any case)
+    /// @param osArch  the raw `os.arch` value (any case)
+    /// @return the `<os>-<arch>` classifier naming the platform's native jar
+    /// @throws UnsatisfiedLinkError if the CPU architecture is not supported
+    static String classifier(String osName, String osArch) {
+        String os = osName.toLowerCase(Locale.ROOT);
+        String arch = osArch.toLowerCase(Locale.ROOT);
+        String osPart;
         if (os.contains("mac") || os.contains("darwin")) {
-            osName = "osx";
+            osPart = "osx";
         } else if (os.contains("win")) {
-            osName = "windows";
+            osPart = "windows";
         } else {
-            osName = "linux";
+            osPart = "linux";
         }
-        String archName;
+        String archPart;
         if (arch.equals("aarch64") || arch.equals("arm64")) {
-            archName = "aarch64";
+            archPart = "aarch64";
         } else if (arch.equals("x86_64") || arch.equals("amd64")) {
-            archName = "x86_64";
+            archPart = "x86_64";
         } else {
             throw new UnsatisfiedLinkError(
                     "Unsupported CPU architecture '" + arch + "'; zstd-java ships native libraries "
                             + "only for x86_64 and aarch64");
         }
-        return osName + "-" + archName;
+        return osPart + "-" + archPart;
     }
 
     private NativeLibrary() {

zstd/src/test/java/io/github/dfa1/zstd/NativeLibraryTest.java

@@ -0,0 +1,72 @@
+package io.github.dfa1.zstd;
+
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class NativeLibraryTest {
+
+    @Nested
+    class Classifier {
+
+        @ParameterizedTest
+        @CsvSource({
+            // os.name variants -> os part
+            "Mac OS X,        aarch64, osx-aarch64",
+            "Darwin,          arm64,   osx-aarch64",
+            "Windows 11,      amd64,   windows-x86_64",
+            "Windows 11,      aarch64, windows-aarch64",
+            "Linux,           x86_64,  linux-x86_64",
+            // unknown os falls back to linux; arch aliases normalise
+            "FreeBSD,         aarch64, linux-aarch64",
+            "Linux,           amd64,   linux-x86_64",
+            "Linux,           arm64,   linux-aarch64",
+        })
+        void mapsOsAndArchToClassifier(String osName, String osArch, String expected) {
+            // Given a JVM os.name / os.arch pair, in mixed case
+            // When mapped to a native-jar classifier
+            String classifier = NativeLibrary.classifier(osName, osArch);
+
+            // Then it names the matching platform's native jar
+            assertThat(classifier).isEqualTo(expected);
+        }
+
+        @Test
+        void rejectsUnsupportedArchitecture() {
+            // Given a CPU architecture this library ships no native jar for
+            ThrowingCallable result = () -> NativeLibrary.classifier("Linux", "sparc");
+
+            // Then it fails fast naming the offending arch, not a cryptic dlopen error
+            assertThatThrownBy(result)
+                    .isInstanceOf(UnsatisfiedLinkError.class)
+                    .hasMessageContaining("sparc");
+        }
+    }
+
+    @Nested
+    class LibraryExtension {
+
+        @ParameterizedTest
+        @CsvSource({
+            "osx-aarch64,     dylib",
+            "osx-x86_64,      dylib",
+            "windows-x86_64,  dll",
+            "windows-aarch64, dll",
+            "linux-x86_64,    so",
+            "linux-aarch64,   so",
+        })
+        void mapsClassifierToSharedLibraryExtension(String classifier, String extension) {
+            // Given a platform classifier
+            // When its shared-library extension is resolved
+            String ext = NativeLibrary.libExtension(classifier);
+
+            // Then it matches the platform's native library suffix
+            assertThat(ext).isEqualTo(extension);
+        }
+    }
+}