IntervalRule rule = new IntervalRule("10:00", "18:00", "1", 1000); // Sunday only

        // Test day overflow (day 8 should be treated as day 1)
        // For same-day rules, it should check the day directly
        assertTrue(rule.isTarget(12, 30, 8)); // Should be treated as day 1 (Sunday)

        // Test with cross-midnight rule
        IntervalRule crossRule = new IntervalRule("22:00", "02:00", "1", 1000); // Sunday only

   * the result is chosen uniformly at random in [0, numBits), and then the result is chosen in that
   * range uniformly at random. Zero is treated as having log2 == 0.
   */
  static BigInteger randomNonNegativeBigInteger(int numBits) {
    int digits = RANDOM_SOURCE.nextInt(numBits);
    if (digits == 0) {
      return new BigInteger(1, RANDOM_SOURCE);

 * Extends the standard plugin DeleteForm to provide JSON request body functionality
 * for REST API operations.
 */
public class DeleteBody extends DeleteForm {

    /**
     * Creates a new instance of DeleteBody.
     * This constructor initializes the request body for plugin deletion API operations,
     * extending the standard plugin DeleteForm with JSON request body functionality.
     */

 */
public class OptionalUtil {

    /**
     * Default constructor.
     */
    private OptionalUtil() {
        // Default constructor
    }

    /**
     * Creates an OptionalEntity from a nullable entity.
     *
     * @param <T> the type of the entity
     * @param entity the entity (can be null)
     * @return the OptionalEntity
     */

                log.error("Failed to create singleton JCIFS context", e);
            }
        }
        return INSTANCE;
    }

    /**
     * This static method registers the SMB URL protocol handler which is
     * required to use SMB URLs with the <code>java.net.URL</code> class. If this
     * method is not called before attempting to create an SMB URL with the

        .of(MANY_VALUES_MEAN);
    assertThat(manyValuesAccumulatorByAddAllStatsAccumulator.mean())
        .isWithin(ALLOWED_ERROR)
        .of(MANY_VALUES_MEAN);
    // For datasets of many double values created from an iterable, we test many combinations of
    // finite and non-finite values:
    for (ManyValues values : ALL_MANY_VALUES) {
      StatsAccumulator accumulator = new StatsAccumulator();

   * @return {@link Inet4Address} corresponding to the supplied byte array
   * @throws IllegalArgumentException if a valid {@link Inet4Address} can not be created
   */
  private static Inet4Address getInet4Address(byte[] bytes) {
    checkArgument(
        bytes.length == 4,
        "Byte array has invalid length for an IPv4 address: %s != 4.",
        bytes.length);

        // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of
        // static initializer. But there seems no way to tell in that case. :(
        // This may cause issues when an anonymous class is created inside a static initializer,
        // and the class's constructor's first parameter happens to be the enclosing class.
        // In such case, we may mistakenly think that the class is within a non-static context

     * The name of the method.
     */
    private final String methodName;

    /**
     * The classes of the method arguments.
     */
    private final Class<?>[] methodArgClasses;

    /**
     * Creates a {@link MethodNotFoundRuntimeException}.
     *
     * @param targetClass
     *            Target class
     * @param methodName
     *            Method name
     * @param methodArgs

@GwtIncompatible
@J2ktIncompatible
@NullMarked
abstract class DummyProxy {

  /**
   * Returns a new proxy for {@code interfaceType}. Proxies of the same interface are equal to each
   * other if the {@link DummyProxy} instance that created the proxies are equal.
   */
  final <T> T newProxy(TypeToken<T> interfaceType) {
    Set<Class<?>> interfaceClasses = new LinkedHashSet<>();