feat: ValuePool can load files that match directory patterns

Author: oetr

src/main/java/com/code_intelligence/jazzer/junit/FuzzTestExecutor.java

@@ -178,6 +178,8 @@ private static Path addInputAndSeedDirs(
         Paths.get(context.getConfigurationParameter("jazzer.internal.basedir").orElse(""))
             .toAbsolutePath();
 
+    System.setProperty("jazzer.internal.basedir", baseDir.toString());
+
     // Use the specified corpus dir, if given, otherwise store the generated corpus in a per-class
     // directory under the project root.
     // The path is specified relative to the current working directory, which with JUnit is the

src/main/java/com/code_intelligence/jazzer/mutation/annotation/ValuePool.java

@@ -27,7 +27,7 @@
 import java.lang.annotation.Target;
 
 /**
- * Provides values to user-selected mutator types to start fuzzing from.
+ * Provides values to user-selected types that will be used during mutation.
  *
  * <p>This annotation can be applied to fuzz test methods and any parameter type or subtype. By
  * default, this annotation is propagated to all nested subtypes unless specified otherwise via the
@@ -68,11 +68,35 @@
 public @interface ValuePool {
   /**
    * Specifies supplier methods that generate values for fuzzing the annotated method or type. The
-   * specified supplier methods must be static and return a {@code Stream <?>} of values. The values
+   * specified supplier methods must be static and return a {@code Stream<?>} of values. The values
    * don't need to match the type of the annotated method or parameter. The mutation framework will
    * extract only the values that are compatible with the target type.
    */
-  String[] value();
+  String[] value() default {};
+
+  /**
+   * Specifies glob patterns matching files that should be provided as {@code byte[]} to the
+   * annotated type. The syntax follows closely to Java's {@link
+   * java.nio.file.FileSystem#getPathMatcher(String) PathMatcher} "glob:" syntax.
+   *
+   * <p>Relative glob patterns are resolved against the working directory.
+   *
+   * <p><i>Note: Patterns that start with <code>{</code> or <code>[</code> are treated as relative
+   * to the working directory.</i>
+   *
+   * <p>Examples:
+   *
+   * <ul>
+   *   <li>{@code *.jpeg} - matches all jpegs in the working directory
+   *   <li>{@code **.xml} - matches all xml files recursively
+   *   <li>{@code src/test/resources/dict/*.txt} - matches txt files in a specific directory
+   *   <li>{@code /absolute/path/to/some/directory/**} - matches all files in an absolute path
+   *       recursively
+   *   <li><code>{"*.jpg", "**.png"}</code> - matches all jpg in the working directory, and png
+   *       files recursively
+   * </ul>
+   */
+  String[] files() default {};
 
   /**
    * This {@code ValuePool} will be used with probability {@code p} by the mutator responsible for
@@ -82,7 +106,7 @@
 
   /**
    * Defines the scope of the annotation. Possible values are defined in {@link
-   * com.code_intelligence.jazzer.mutation.utils.PropertyConstraint}. By default it's {@code
+   * com.code_intelligence.jazzer.mutation.utils.PropertyConstraint}. By default, it's {@code
    * RECURSIVE}.
    */
   String constraint() default RECURSIVE;

src/main/java/com/code_intelligence/jazzer/mutation/mutator/lang/ValuePoolMutatorFactory.java

@@ -41,7 +41,6 @@
 import java.util.Optional;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 public class ValuePoolMutatorFactory implements MutatorFactory {
   /** Types annotated with this marker wil not be re-wrapped by this factory. */
@@ -91,14 +90,9 @@ static <T> SerializingMutator<T> wrapIfValuesExist(
         return mutator;
       }
 
-      Optional<Stream<?>> rawUserValues = valuePoolRegistry.extractRawValues(type);
-      if (!rawUserValues.isPresent()) {
-        return mutator;
-      }
-
       List<T> userValues =
-          rawUserValues
-              .get()
+          valuePoolRegistry
+              .extractUserValues(type)
               // Values whose round trip serialization is not stable violate either some user
               // annotations on the type (e.g. @InRange), or the default mutator limits (e.g.
               // default List size limits) and are therefore not suitable for inclusion in the value

src/main/java/com/code_intelligence/jazzer/mutation/support/GlobUtils.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2026 Code Intelligence GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.code_intelligence.jazzer.mutation.support;
+
+import static java.util.Collections.EMPTY_LIST;
+
+import java.io.IOException;
+import java.nio.file.FileSystems;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.nio.file.Paths;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class GlobUtils {
+  protected static List<Path> collectPathsForGlob(Path baseDir, String glob) {
+    if (ON_WINDOWS) {
+      glob = glob.replace("\\\\", "/");
+    }
+    int firstGlobChar = indexOfFirstGlobChar(glob);
+    if (firstGlobChar == -1) {
+      Path target = baseDir.resolve(unescapeGlobChars(glob)).toAbsolutePath().normalize();
+      return Files.isRegularFile(target) ? Arrays.asList(target) : EMPTY_LIST;
+    }
+
+    String prefix = glob.substring(0, firstGlobChar);
+    int lastSeparator =
+        ON_WINDOWS
+            ? Math.max(prefix.lastIndexOf('/'), prefix.lastIndexOf("\\\\"))
+            : prefix.lastIndexOf('/');
+
+    // The 'start' path is always absolute
+    Path start;
+    String remainingPattern;
+    if (lastSeparator == -1) {
+      start = baseDir.toAbsolutePath().normalize();
+      remainingPattern = glob;
+    } else {
+      String basePrefix = prefix.substring(0, lastSeparator);
+      start = baseDir.resolve(unescapeGlobChars(basePrefix)).toAbsolutePath().normalize();
+      remainingPattern = glob.substring(lastSeparator + 1);
+    }
+    if (!Files.exists(start)) {
+      return EMPTY_LIST;
+    }
+
+    // The matcher is always relative to start path
+    PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:" + remainingPattern);
+
+    List<Path> matches = new ArrayList<>();
+    try {
+      Files.walkFileTree(
+          start,
+          new SimpleFileVisitor<Path>() {
+            @Override
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+              if (!Files.isRegularFile(file)) {
+                return FileVisitResult.CONTINUE;
+              }
+              Path relativePath = start.relativize(file);
+              if (matcher.matches(relativePath)) {
+                matches.add(file);
+              }
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult visitFileFailed(Path file, IOException exc) {
+              return FileVisitResult.CONTINUE;
+            }
+          });
+    } catch (IOException ignored) {
+      // Best effort - return what we found so far
+    }
+    return matches;
+  }
+
+  private static final String SPECIAL_CHARS = "*{}[]-?\\";
+
+  private static boolean isSpecialChar(char c) {
+    return SPECIAL_CHARS.indexOf(c) != -1;
+  }
+
+  protected static Path unescapeGlobChars(String glob) {
+    StringBuilder sb = new StringBuilder();
+    char[] chars = glob.toCharArray();
+    boolean escaped = false;
+
+    for (char c : chars) {
+      if (escaped) {
+        if (!isSpecialChar(c)) {
+          sb.append('\\');
+        }
+        sb.append(c);
+        escaped = false;
+      } else if (c == '\\') {
+        escaped = true;
+      } else {
+        sb.append(c);
+      }
+    }
+
+    return Paths.get(sb.toString());
+  }
+
+  private static final String GLOB_CHARS = "*?[{";
+
+  private static boolean isGlobChar(char c) {
+    return GLOB_CHARS.indexOf(c) != -1;
+  }
+
+  protected static final boolean ON_WINDOWS = FileSystems.getDefault().getSeparator().equals("\\");
+
+  private static int indexOfFirstGlobChar(String glob) {
+    char[] chars = glob.toCharArray();
+    boolean escaped = false;
+    for (int i = 0; i < chars.length; i++) {
+      char c = chars[i];
+      if (escaped) {
+        escaped = false;
+        continue;
+      } else if (c == '\\') {
+        escaped = true;
+      }
+      if (isGlobChar(c)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+}