assertThrows(NoSuchElementException.class, iter::peek);
  }


  @J2ktIncompatible // weak references, details of GC
  @GwtIncompatible // weak references
  @AndroidIncompatible // depends on details of GC
  public void testFreesNextReference() {
    Iterator<Object> itr =
        new AbstractIterator<Object>() {
          @Override
          public Object computeNext() {

     * Enables garbage collection logging for this job execution.
     * Configures JVM options for comprehensive GC logging with rotation.
     *
     * @return this ExecJob instance for method chaining
     */
    public ExecJob gcLogging() {
        final StringBuilder buf = new StringBuilder(100);
        buf.append("-Xlog:gc*,gc+age=trace,safepoint:file=");
        if (logFilePath != null) {
            buf.append(logFilePath);

import org.jspecify.annotations.NullUnmarked;

/**
 * Simple benchmark: create, start, read. This does not currently report the most useful result
 * because it's ambiguous to what extent the stopwatch benchmark is being affected by GC.
 *
 * @author Kevin Bourrillion
 */
@NullUnmarked
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {

            jvmPoolObj.capacity = p.getTotalCapacity().getBytes();
            return jvmPoolObj;
        }).toArray(n -> new JvmPoolObj[n]);
        final GarbageCollectors gc = jvmStats.getGc();
        jvmObj.gc = Arrays.stream(gc.getCollectors()).map(c -> {
            final JvmGcObj jvmGcObj = new JvmGcObj();
            jvmGcObj.key = c.getName();
            jvmGcObj.count = c.getCollectionCount();

				return nil
			}
			gc := gridConn.Load()
			if gc != nil {
				return gc
			}
			gm := globalGrid.Load()
			if gm == nil {
				return nil
			}
			gc = gm.Connection(gridHost)
			if gc == nil {
				bugLogIf(context.Background(), fmt.Errorf("gridHost %q not found for peer %s", gridHost, peer.String()), peer.String()+":gridHost")

DATA_DIR=${packaging.fess.var.dir}

# Fess configuration directory
CONF_DIR=${packaging.fess.conf.dir}

# Maximum number of VMA (Virtual Memory Areas) a process can own
MAX_MAP_COUNT=262144

# Path to the GC log file
#FESS_GC_LOG_FILE=/var/log/fess/gc.log

# Fess PID file directory
PID_DIR=${packaging.fess.pid.dir}

# End of variables that can be overwritten in $DEFAULT

# overwrite settings from default file
if [ -f "$DEFAULT" ]; then

		// For example, if len(stats.PauseQuantiles) is 5, it will be
		// filled with the minimum, 25%, 50%, 75%, and maximum pause times.
		PauseQuantiles: make([]time.Duration, 5),
	}
	debug.ReadGCStats(&gcStats)
	// Truncate GC stats to max 5 entries.
	if len(gcStats.PauseEnd) > 5 {
		gcStats.PauseEnd = gcStats.PauseEnd[len(gcStats.PauseEnd)-5:]
	}
	if len(gcStats.Pause) > 5 {
		gcStats.Pause = gcStats.Pause[len(gcStats.Pause)-5:]
	}

import org.jspecify.annotations.NullUnmarked;

/**
 * Simple benchmark: create, start, read. This does not currently report the most useful result
 * because it's ambiguous to what extent the stopwatch benchmark is being affected by GC.
 *
 * @author Kevin Bourrillion
 */
@NullUnmarked
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {

    /**
     * Release a temporary buffer
     *
     * For direct buffers, we rely on GC. A more sophisticated
     * implementation could maintain a buffer pool here as well.
     *
     * @param buffer buffer to release
     */
    public void releaseBuffer(ByteBuffer buffer) {
        // For direct buffers, we rely on GC
        // Could implement a more sophisticated buffer pool here
    }

    /**

    - name: Cleanup Gradle Cache
      # Cleans up the Gradle caches before being cached
      run: |
        rm -f ~/.gradle/caches/modules-2/modules-2.lock
        rm -f ~/.gradle/caches/modules-2/gc.properties