Add real fixture probe and validation coverage

Add parameterized facade tests that run against real example media files
to verify detected mime type, extension, media type, and strict
validation success.

Include shared fixture expectations and example resources to improve
regression coverage across audio, video, and image formats, plus new
round-trip conversion test scaffolding.

Author: TamKungZ

README.md

@@ -12,7 +12,7 @@ CodecMedia is a Java library for media probing, validation, metadata sidecar per
   <img src="https://codecmedia.tamkungz.me/CodecMedia_Full_Logo.png" width="70%" alt="CodecMedia Logo">
 </p>
 
-## Approaches:
+## Approaches
 - Zero-Dependency
 - Self-Contained
 - Multi-Platform

src/test/java/me/tamkungz/codecmedia/CodecMediaFacadeTest.java

@@ -5,6 +5,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Map;
+import java.util.stream.Stream;
 
 import javax.imageio.ImageIO;
 
@@ -13,15 +14,53 @@
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class CodecMediaFacadeTest {
 
+    private record ExampleFixtureExpectation(
+            String fileName,
+            String mimeType,
+            String extension,
+            me.tamkungz.codecmedia.model.MediaType mediaType
+    ) {
+    }
+
     @Test
     void createDefault_shouldReturnEngine() {
         CodecMediaEngine engine = CodecMedia.createDefault();
         assertNotNull(engine);
     }
 
+    @ParameterizedTest(name = "probe real fixture: {0}")
+    @MethodSource("exampleFixtures")
+    void probe_shouldDetectRealExampleFixtures(ExampleFixtureExpectation fixture) throws Exception {
+        CodecMediaEngine engine = CodecMedia.createDefault();
+        Path input = Path.of("src/test/resources/example", fixture.fileName());
+
+        assertTrue(Files.exists(input));
+
+        var result = engine.probe(input);
+        assertEquals(fixture.mimeType(), result.mimeType());
+        assertEquals(fixture.extension(), result.extension());
+        assertEquals(fixture.mediaType(), result.mediaType());
+        assertTrue(result.tags().containsKey("sizeBytes"));
+    }
+
+    @ParameterizedTest(name = "validate real fixture: {0}")
+    @MethodSource("exampleFixtures")
+    void validate_strictShouldAcceptRealExampleFixtures(ExampleFixtureExpectation fixture) throws Exception {
+        CodecMediaEngine engine = CodecMedia.createDefault();
+        Path input = Path.of("src/test/resources/example", fixture.fileName());
+
+        assertTrue(Files.exists(input));
+
+        var result = engine.validate(input, new me.tamkungz.codecmedia.options.ValidationOptions(true, 0));
+        assertTrue(result.valid());
+        assertTrue(result.errors().isEmpty());
+    }
+
     @Test
     void probe_shouldDetectMp3ByExtension() throws Exception {
         CodecMediaEngine engine = CodecMedia.createDefault();
@@ -705,4 +744,17 @@ private static void deleteDirectory(Path dir) throws IOException {
             });
         }
     }
+
+    private static Stream<ExampleFixtureExpectation> exampleFixtures() {
+        return Stream.of(
+                new ExampleFixtureExpectation("file_example_MP3_1MG.mp3", "audio/mpeg", "mp3", me.tamkungz.codecmedia.model.MediaType.AUDIO),
+                new ExampleFixtureExpectation("file_example_MP3_700KB.mp3", "audio/mpeg", "mp3", me.tamkungz.codecmedia.model.MediaType.AUDIO),
+                new ExampleFixtureExpectation("file_example_MP4_480_1_5MG.mp4", "video/mp4", "mp4", me.tamkungz.codecmedia.model.MediaType.VIDEO),
+                new ExampleFixtureExpectation("file_example_MP4_640_3MG.mp4", "video/mp4", "mp4", me.tamkungz.codecmedia.model.MediaType.VIDEO),
+                new ExampleFixtureExpectation("file_example_PNG_1MB.png", "image/png", "png", me.tamkungz.codecmedia.model.MediaType.IMAGE),
+                new ExampleFixtureExpectation("file_example_PNG_500kB.png", "image/png", "png", me.tamkungz.codecmedia.model.MediaType.IMAGE),
+                new ExampleFixtureExpectation("file_example_WEBM_480_900KB.webm", "video/webm", "webm", me.tamkungz.codecmedia.model.MediaType.VIDEO),
+                new ExampleFixtureExpectation("file_example_WEBM_640_1_4MB.webm", "video/webm", "webm", me.tamkungz.codecmedia.model.MediaType.VIDEO)
+        );
+    }
 }

src/test/java/me/tamkungz/codecmedia/CodecMediaRoundTripConversionTest.java

@@ -0,0 +1,89 @@
+package me.tamkungz.codecmedia;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import me.tamkungz.codecmedia.model.MediaType;
+import me.tamkungz.codecmedia.options.ConversionOptions;
+
+class CodecMediaRoundTripConversionTest {
+
+    private record FixtureExpectation(
+            String fileName,
+            String extension,
+            String mimeType,
+            MediaType mediaType
+    ) {
+    }
+
+    @ParameterizedTest(name = "round-trip same extension: {0}")
+    @MethodSource("exampleFixtures")
+    void convert_roundTripSameExtension_shouldWorkForAllExampleFixtures(FixtureExpectation fixture) throws Exception {
+        CodecMediaEngine engine = CodecMedia.createDefault();
+        Path input = Path.of("src/test/resources/example", fixture.fileName());
+        Path workDir = Files.createTempDirectory("codecmedia-roundtrip-");
+
+        try {
+            assertTrue(Files.exists(input));
+
+            Path firstOutput = workDir.resolve("step1." + fixture.extension());
+            var first = engine.convert(input, firstOutput, new ConversionOptions(fixture.extension(), "balanced", true));
+
+            assertTrue(Files.exists(first.outputFile()));
+            assertTrue(Files.size(first.outputFile()) > 0);
+            assertEquals(fixture.extension(), first.format());
+            assertFalse(first.reencoded());
+
+            Path secondOutput = workDir.resolve("step2." + fixture.extension());
+            var second = engine.convert(first.outputFile(), secondOutput, new ConversionOptions(fixture.extension(), "balanced", true));
+
+            assertTrue(Files.exists(second.outputFile()));
+            assertTrue(Files.size(second.outputFile()) > 0);
+            assertEquals(fixture.extension(), second.format());
+            assertFalse(second.reencoded());
+
+            var probed = engine.probe(second.outputFile());
+            assertEquals(fixture.mimeType(), probed.mimeType());
+            assertEquals(fixture.extension(), probed.extension());
+            assertEquals(fixture.mediaType(), probed.mediaType());
+        } finally {
+            deleteDirectory(workDir);
+        }
+    }
+
+    private static Stream<FixtureExpectation> exampleFixtures() {
+        return Stream.of(
+                new FixtureExpectation("file_example_MP3_1MG.mp3", "mp3", "audio/mpeg", MediaType.AUDIO),
+                new FixtureExpectation("file_example_MP3_700KB.mp3", "mp3", "audio/mpeg", MediaType.AUDIO),
+                new FixtureExpectation("file_example_MP4_480_1_5MG.mp4", "mp4", "video/mp4", MediaType.VIDEO),
+                new FixtureExpectation("file_example_MP4_640_3MG.mp4", "mp4", "video/mp4", MediaType.VIDEO),
+                new FixtureExpectation("file_example_PNG_1MB.png", "png", "image/png", MediaType.IMAGE),
+                new FixtureExpectation("file_example_PNG_500kB.png", "png", "image/png", MediaType.IMAGE),
+                new FixtureExpectation("file_example_WEBM_480_900KB.webm", "webm", "video/webm", MediaType.VIDEO),
+                new FixtureExpectation("file_example_WEBM_640_1_4MB.webm", "webm", "video/webm", MediaType.VIDEO)
+        );
+    }
+
+    private static void deleteDirectory(Path dir) throws IOException {
+        if (!Files.exists(dir)) {
+            return;
+        }
+        try (var walk = Files.walk(dir)) {
+            walk.sorted((a, b) -> b.compareTo(a)).forEach(path -> {
+                try {
+                    Files.deleteIfExists(path);
+                } catch (IOException ignored) {
+                    // ignore cleanup errors in tests
+                }
+            });
+        }
+    }
+}