import java.util.concurrent.atomic.AtomicInteger;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests relating to cache expiration: make sure entries expire at the right times, make sure
 * expired entries don't show up, etc.
 *
 * @author mike nonemacher
 */
@SuppressWarnings("deprecation") // tests of deprecated method
@NullUnmarked
public class CacheExpirationTest extends TestCase {

				Computed: etag,
			}
		}
	}
	return n, err
}

// ETag returns the ETag of all the content read
// so far. Reading more content changes the MD5
// checksum. Therefore, calling ETag multiple
// times may return different results.
func (r *Reader) ETag() ETag {
	sum := r.md5.Sum(nil)
	return ETag(sum)
}

// VerifyError is an error signaling that a
// computed ETag does not match an expected
// ETag.

   * operation in order to trigger shutdown, consider instead registering a listener and
   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the
   * same times as {@code triggerShutdown}.
   */
  protected void triggerShutdown() {}

  /**
   * Returns the {@link Executor} that will be used to run this service. Subclasses may override

   * features to support (from the enclosing {@link AbstractIteratorTester} instance). Instead of
   * throwing exceptions like {@link NoSuchElementException} at the appropriate times, it throws
   * {@link PermittedMetaException} instances, which wrap a set of all exceptions that the iterator
   * could throw during the invocation of that method. This is necessary because, e.g., a call to

    n_ask_attempts: (Integer) Number of times to query for valid input before
      raising an error and quitting.

  Returns:
    [String] The value of var_name after querying for input.

  Raises:
    UserInputError: if a query has been attempted n_ask_attempts times without
      success, assume that the user has made a scripting error, and will

                if (file.getName().equals("package-info.java")) {
                    if (canonicalPackageInfos.contains(file.getAbsoluteFile())) {
                        // The file collection may be resolved several times, e.g. for fingerprinting and for actual javadoc invocation.
                        // The method should be idempotent, so we record all package-info.java files we ever allowed and allow them afterward.

		}
	}
}

// time a scanner action.
// Use for s < scannerMetricLastRealtime
func (p *scannerMetrics) time(s scannerMetric) func() {
	startTime := time.Now()
	return func() {
		duration := time.Since(startTime)

		atomic.AddUint64(&p.operations[s], 1)
		if s < scannerMetricLastRealtime {
			p.latency[s].add(duration)
		}
	}
}

// timeSize add time and size of a scanner action.

   * operation in order to trigger shutdown, consider instead registering a listener and
   * implementing {@code stopping}. Note, however, that {@code stopping} does not run at exactly the
   * same times as {@code triggerShutdown}.
   */
  protected void triggerShutdown() {}

  /**
   * Returns the {@link Executor} that will be used to run this service. Subclasses may override

        // of A, B, C, and D, so when scanning B and D, E will be added again 'filtered'.
        //
        // Without de-duplication, the final list would contain E three times, once for E being in the projects and
        // whitelisted, and twice more for E being a downstream dependency of B and D.
        return filtered.stream().distinct().toList();
    }

    @Override

		}
		m.Aggregated.Mem.Info = madmin.GetMemInfo(GlobalContext, byHostName)
	}
	if types.Contains(madmin.MetricsCPU) {
		m.Aggregated.CPU = &madmin.CPUMetrics{
			CollectedAt: UTCNow(),
		}
		cm, err := c.Times(false)
		if err != nil {
			m.Errors = append(m.Errors, fmt.Sprintf("%s: %v (cpuTimes)", byHostName, err.Error()))
		} else {
			// not collecting per-cpu stats, so there will be only one element
			if len(cm) == 1 {