actualStems = reconstructAllStemCandidates(trie, variant);
+
+ assertAll(
+ () -> assertNotNull(preferredPatch,
+ "A preferred patch must be available for representative variant '" + variant + "' in "
+ + scenario + '.'),
+ () -> assertFalse(actualStems.isEmpty(),
+ "At least one stem candidate must be returned for representative variant '" + variant
+ + "' in " + scenario + '.'),
+ () -> assertTrue(actualStems.containsAll(expectedStems),
+ "All acceptable stems must be preserved for representative variant '" + variant
+ + "' in " + scenario + ". Expected=" + expectedStems + ", actual="
+ + actualStems),
+ () -> assertTrue(expectedStems.contains(PatchCommandEncoder.apply(variant, preferredPatch)),
+ "The preferred stem must be one of the acceptable stems for representative variant '"
+ + variant + "' in " + scenario + '.'));
+ }
+ }
+ }
+
+ /**
+ * Copies one classpath resource to a temporary file so that the CLI is
+ * exercised through its real file-based contract.
+ *
+ * @param resourcePath classpath resource path
+ * @param fileName target temporary file name
+ * @return copied temporary file
+ * @throws IOException if the resource cannot be found or copied
+ */
+ private Path copyResourceToTemporaryFile(final String resourcePath, final String fileName) throws IOException {
+ final Path targetFile = tempDir.resolve(fileName);
+ final Path parentDirectory = targetFile.toAbsolutePath().getParent();
+
+ if (parentDirectory != null) {
+ Files.createDirectories(parentDirectory);
+ }
+
+ try (InputStream inputStream = openResource(resourcePath)) {
+ Files.copy(inputStream, targetFile);
+ }
+
+ return targetFile;
+ }
+
+ /**
+ * Opens one classpath resource.
+ *
+ * @param resourcePath classpath resource path
+ * @return opened input stream
+ * @throws IOException if the resource cannot be found
+ */
+ private static InputStream openResource(final String resourcePath) throws IOException {
+ final InputStream inputStream = CompileIntegrationTest.class.getClassLoader().getResourceAsStream(resourcePath);
+ if (inputStream == null) {
+ throw new IOException("Classpath resource not found: " + resourcePath);
+ }
+ return inputStream;
+ }
+
+ /**
+ * Reads representative variant expectations from a bundled project dictionary.
+ *
+ *
+ * This helper scans the source dictionary in a byte-preserving single-byte
+ * charset and selects only ASCII-safe probe terms. That keeps the
+ * multidictionary integration assertions stable even when the bundled resources
+ * use heterogeneous encodings, while still validating the CLI against the real
+ * shipped dictionaries.
+ *
+ *
+ *
+ * The dictionary format is expected to be:
+ *
+ *
+ *
+ * stem variant1 variant2 ...
+ *
+ *
+ *
+ * Lines beginning with comment prefixes or blank lines are ignored. Canonical
+ * stems are intentionally excluded from the expectation map unless they also
+ * appear as distinct variants on a source line.
+ *
+ *
+ * @param resourcePath bundled dictionary resource path
+ * @param limit maximum number of representative variants to collect
+ * @return representative variants mapped to their acceptable stems
+ * @throws IOException if reading fails
+ */
+ private static Map> readRepresentativeVariantExpectations(final String resourcePath,
+ final int limit) throws IOException {
+ final Map> expectations = new LinkedHashMap>();
+
+ try (InputStream inputStream = openResource(resourcePath);
+ BufferedReader reader = new BufferedReader(
+ new InputStreamReader(inputStream, BUNDLED_PROBE_SCAN_CHARSET))) {
+ for (String line = reader.readLine(); line != null; line = reader.readLine()) {
+ if (expectations.size() >= limit) {
+ break;
+ }
+
+ final String trimmedLine = line.trim();
+ if (trimmedLine.isEmpty() || trimmedLine.startsWith("#") || trimmedLine.startsWith("//")) {
+ continue;
+ }
+
+ final String[] tokens = trimmedLine.split("\\s+");
+ if (tokens.length < 2) {
+ continue;
+ }
+
+ final String stem = tokens[0];
+ if (!isAsciiProbeToken(stem)) {
+ continue;
+ }
+
+ for (int index = 1; index < tokens.length && expectations.size() < limit; index++) {
+ final String variant = tokens[index];
+
+ if (!isAsciiProbeToken(variant) || variant.equals(stem)) {
+ continue;
+ }
+
+ registerExpectedStem(expectations, variant, stem);
+ }
+ }
+ }
+
+ return expectations;
+ }
+
+ /**
+ * Determines whether one token is suitable for stable ASCII-safe bundled
+ * multidictionary probing.
+ *
+ * @param token token to inspect
+ * @return {@code true} when the token is a non-empty lower-case ASCII letter
+ * sequence
+ */
+ private static boolean isAsciiProbeToken(final String token) {
+ if (token == null || token.isEmpty()) {
+ return false;
+ }
+
+ for (int index = 0; index < token.length(); index++) {
+ final char character = token.charAt(index);
+ if (character < 'a' || character > 'z') {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Registers one acceptable stem for one input word.
+ *
+ * @param expectedStemsByWord expectation map
+ * @param word input word
+ * @param stem acceptable stem
+ */
+ private static void registerExpectedStem(final Map> expectedStemsByWord, final String word,
+ final String stem) {
+ Set stems = expectedStemsByWord.get(word);
+ if (stems == null) {
+ stems = new LinkedHashSet();
+ expectedStemsByWord.put(word, stems);
+ }
+ stems.add(stem);
+ }
+
+ /**
+ * Reconstructs all stem candidates returned by the trie for one input word.
+ *
+ * @param trie compiled trie
+ * @param word input word
+ * @return reconstructed stem candidates
+ */
+ private static Set reconstructAllStemCandidates(final FrequencyTrie trie, final String word) {
+ final String[] patchCommands = trie.getAll(word);
+ final Set stems = new LinkedHashSet();
+
+ if (patchCommands == null) {
+ return stems;
+ }
+
+ for (String patchCommand : patchCommands) {
+ stems.add(PatchCommandEncoder.apply(word, patchCommand));
+ }
+
+ return stems;
+ }
+
+ /**
+ * Verifies that one compiled artifact starts with the standard GZip magic
+ * header.
+ *
+ * @param artifactFile compiled artifact file
+ * @throws IOException if the file cannot be read
+ */
+ private static void assertGzipCompressed(final Path artifactFile) throws IOException {
+ final byte[] bytes = Files.readAllBytes(artifactFile);
+
+ assertTrue(bytes.length >= 2, "A GZip artifact must contain at least the two magic header bytes.");
+ assertEquals(0x1F, bytes[0] & 0xFF, "The first GZip magic byte must match.");
+ assertEquals(0x8B, bytes[1] & 0xFF, "The second GZip magic byte must match.");
+ }
+
+ /**
+ * Executes {@link Compile#run(String...)} while capturing {@code System.err}.
+ *
+ * @param arguments CLI arguments
+ * @return captured command result
+ */
+ private static CommandResult runWithCapturedStandardError(final String... arguments) {
+ final PrintStream originalStandardError = System.err;
+ final ByteArrayOutputStream capturedStandardError = new ByteArrayOutputStream();
+
+ try (PrintStream replacementStandardError = new PrintStream(capturedStandardError, true,
+ StandardCharsets.UTF_8)) {
+ System.setErr(replacementStandardError);
+ final int exitCode = Compile.run(arguments);
+ replacementStandardError.flush();
+ return new CommandResult(exitCode, capturedStandardError.toString(StandardCharsets.UTF_8));
+ } finally {
+ System.setErr(originalStandardError);
+ }
+ }
+
+ /**
+ * Captured CLI result.
+ *
+ * @param exitCode process exit code
+ * @param standardError captured standard error
+ */
+ private record CommandResult(int exitCode, String standardError) {
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/org/egothor/stemmer/CompileTest.java b/src/test/java/org/egothor/stemmer/CompileTest.java
index dd08426..a240776 100644
--- a/src/test/java/org/egothor/stemmer/CompileTest.java
+++ b/src/test/java/org/egothor/stemmer/CompileTest.java
@@ -37,7 +37,6 @@ import org.junit.jupiter.api.io.TempDir;
*
*/
@Tag("unit")
-@Tag("cli")
@DisplayName("Compile")
class CompileTest {
diff --git a/src/test/resources/org/egothor/stemmer/compile/remark-aware-dictionary.txt b/src/test/resources/org/egothor/stemmer/compile/remark-aware-dictionary.txt
new file mode 100644
index 0000000..3a8a9a3
--- /dev/null
+++ b/src/test/resources/org/egothor/stemmer/compile/remark-aware-dictionary.txt
@@ -0,0 +1,8 @@
+# full-line remark
+// full-line slash remark
+
+run running runs runner // trailing remark
+walk walking walks walked
+city cities
+café cafés
+play playing played # trailing remark
\ No newline at end of file