/**
 * Benchmarks for various algorithms for computing the mean and/or variance.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class StatsBenchmark {

  enum MeanAlgorithm {
    SIMPLE {
      @Override
      double mean(double[] values) {
        double sum = 0.0;
        for (double value : values) {
          sum += value;
        }
        return sum / values.length;
      }
    },

    private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
      this.gen = gen;
    }

    @Override
    public SampleElements<E> samples() {
      return gen.samples();
    }

    @Override
    public List<E> create(Object... elements) {
      return (List<E>) SerializableTester.reserialize(gen.create(elements));
    }

    @Override

    }

    @Override
    public PermissionCollection getPermissions(ProtectionDomain pd) {
      return perms;
    }

    @Override
    public boolean implies(ProtectionDomain pd, Permission p) {
      return perms.implies(p);
    }

    @Override
    public void refresh() {}
  }

  /** Returns a policy containing all the permissions we ever need. */

import java.util.List;
import org.jspecify.annotations.NullMarked;

/**
 * A generator using sample elements whose hash codes all collide badly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public abstract class TestCollidingSetGenerator implements TestSetGenerator<Object> {
  @Override
  public SampleElements<Object> samples() {
    return new Colliders();
  }

  @Override

    private final long timeoutMillis;

    /**
     * Creates a simple circuit breaker with default settings
     *
     * @param name the circuit breaker name
     */
    public SimpleCircuitBreaker(String name) {
        this(name, 5, 3, 30000L); // 5 failures, 3 successes, 30 second timeout
    }

    /**
     * Creates a simple circuit breaker
     *
     * @param name the circuit breaker name

/**
 * Tests for SmbBasicFileInfo interface.
 * The tests exercise typical, edge, and null scenarios using a simple
 * implementation and a Mockito mock to verify interactions.
 */
@ExtendWith(MockitoExtension.class)
public class SmbBasicFileInfoTest {

    /**
     * Simple concrete implementation used for testing return values.
     */
    private static class TestInfo implements SmbBasicFileInfo {

    private static final Logger logger = LogManager.getLogger(DataStoreFactory.class);

    /**
     * Map containing registered data store instances indexed by their names and class simple names.
     * All keys are stored in lowercase for case-insensitive lookup.
     */
    protected Map<String, DataStore> dataStoreMap = new LinkedHashMap<>();

    /**

BrokenSessionDep = Annotated[Session, Depends(broken_dep_session)]

app = FastAPI()


@app.get("/data")
def get_data(session: SessionDep) -> Any:
    data = list(session)
    return data


@app.get("/stream-simple")
def get_stream_simple(session: SessionDep) -> Any:
    def iter_data():
        yield from ["x", "y", "z"]

    return StreamingResponse(iter_data())


@app.get("/stream-session")

import org.jspecify.annotations.Nullable;

/**
 * Weak reference with a {@code finalizeReferent()} method which a background thread invokes after
 * the garbage collector reclaims the referent. This is a simpler alternative to using a {@link
 * ReferenceQueue}.
 *
 * @author Bob Lee
 * @since 2.0
 */
@J2ktIncompatible
@GwtIncompatible
public abstract class FinalizableWeakReference<T> extends WeakReference<T>

package ioutil

import (
	"io"
)

// Discard is just like io.Discard without the io.ReaderFrom compatible
// implementation which is buggy on NUMA systems, we have to use a simpler
// io.Writer implementation alone avoids also unnecessary buffer copies,
// and as such incurred latencies.
var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}