long result = current.skip(n);
        if (result > 0) {
          return result;
        }
        advance();
      }
    }
    return 0;
  }

  @Override
  public boolean ready() throws IOException {
    return (current != null) && current.ready();
  }

  @Override
  public void close() throws IOException {
    if (current != null) {
      try {
        current.close();

  public static <E> QueueTestSuiteBuilder<E> using(TestQueueGenerator<E> generator) {
    return new QueueTestSuiteBuilder<E>().usingGenerator(generator);
  }

  private boolean runCollectionTests = true;

  /**
   * Specify whether to skip the general collection tests. Call this method when testing a
   * collection that's both a queue and a list, to avoid running the common collection tests twice.

     *
     * @param version the version to test, must not be {@code null}
     * @return {@code true} if this range contains the specified version, {@code false} otherwise
     */
    boolean contains(@Nonnull Version version);

    /**
     * {@return the string representation of this version}
     */
    @Nonnull
    @Override
    String toString();

            }
        }
    }

    /**
     * Helper method to check if a number is a power of two
     */
    private boolean isPowerOfTwo(int n) {
        return n > 0 && (n & (n - 1)) == 0;
    }

internal open class RecordingConnectionListener(
  /**
   * An override to ignore the normal order that is enforced.
   * EventListeners added by Interceptors will not see all events.
   */
  private val enforceOrder: Boolean = true,
) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableSetOf<Any>()

    replaceWith = ReplaceWith(expression = "localPrincipal"),
    level = DeprecationLevel.ERROR,
  )
  fun localPrincipal(): Principal? = localPrincipal

  override fun equals(other: Any?): Boolean =
    other is Handshake &&
      other.tlsVersion == tlsVersion &&
      other.cipherSuite == cipherSuite &&
      other.peerCertificates == peerCertificates &&
      other.localCertificates == localCertificates

    @Override
    public UserDbm asDBMeta() {
        return UserDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "user";
    }

    @Override
    public boolean hasSpecifiedColumn() {
        return _specification != null;
    }

    @Override
    public ConditionQuery localCQ() {
        return doGetConditionQuery();
    }

	},
	config.KV{
		Key:   DriveWorkers,
		Value: "",
	},
}

const minimumBitrotCycleInMonths = 1

func parseBitrotConfig(s string) (time.Duration, error) {
	// Try to parse as a boolean
	enabled, err := config.ParseBool(s)
	if err == nil {
		switch enabled {
		case true:
			return 0, nil
		case false:
			return -1, nil
		}
	}

	// Try to parse as a number of months

                    "minimumSupported must be at least $minimumMinimum, was $minimumSupported"
                }
            }
        }

        private
        val VersionNumber.isStable: Boolean
            get() = qualifier == null

        private
        fun List<VersionNumber>.applyMinimumSupported(minimumSupported: VersionNumber?): List<VersionNumber> =
            when (minimumSupported) {

    }
    return classes;
  }

  private static boolean hasTest(Class<?> testClass, Iterable<String> testNames) {
    for (String testName : testNames) {
      try {
        testClass.getMethod(testName);
        return true;
      } catch (NoSuchMethodException e) {
        continue;
      }
    }
    return false;
  }

  private static boolean isEqualsDefined(Class<?> cls) {
    try {