*/
package org.codelibs.core.exception;

import javax.crypto.IllegalBlockSizeException;

/**
 * Signals that this exception has been thrown when a block cipher is supplied with input data whose length is not a multiple of the cipher's block size, or that has been padded to the wrong length.
 * @author shinsuke
 */
public class IllegalBlockSizeRuntimeException extends ClRuntimeException {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.tls.internal.der

import okio.ByteString

/**
 * A value whose type is not specified statically. Use this with [Adapters.any] which will attempt
 * to resolve a concrete type.
 */
internal data class AnyValue(
  var tagClass: Int,
  var tag: Long,
  var constructed: Boolean = false,

 * 3.2.3 and earlier are encouraged to use {@link JavaToolchainImpl}.
 * <strong>Note:</strong> This is an internal component whose interface can change without prior notice.
 *
 * @deprecated clients that do not require compatibility with Maven 3.2.3 and earlier should link to
 *             {@link JavaToolchainImpl} instead.
 */
@Deprecated

import org.apache.maven.plugin.LegacySupport;
import org.apache.maven.project.ProjectBuilder;

/**
 * This realizes the metadata source via the default hint to provide backward-compat with Maven 2.x whose Plexus version
 * registered component descriptors twice: once keyed by role+roleHint and once keyed by role only. This effectively
 * made the metadata source available with its original role hint ("maven") as well as the default hint.

import org.apache.maven.artifact.versioning.OverConstrainedVersionException;

/**
 * Resolves conflicting artifacts by always selecting the oldest declaration. Oldest is defined as the
 * declaration whose version is less according to <code>ArtifactVersion.compareTo</code>.
 *
 * @see ArtifactVersion#compareTo
 * @since 3.0
 */
@Named("oldest")
@Singleton
@Deprecated

    return stream.readInt();
  }

  /**
   * Stores the contents of a map in an output stream, as part of serialization. It does not support
   * concurrent maps whose content may change while the method is running.
   *
   * <p>The serialized output consists of the number of entries, first key, first value, second key,
   * second value, and so on.
   */

import com.google.errorprone.annotations.Immutable;
import java.io.Serializable;
import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

/**
 * A {@link ClassToInstanceMap} whose contents will never change, with many other important
 * properties detailed at {@link ImmutableCollection}.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@Immutable(containerOf = "B")
@GwtIncompatible

  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)
  }

  /**
   * Removes recorded events up to (and including) an event is found whose class equals [eventClass]
   * and returns it.
   */
  fun <T : ConnectionEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {

      TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
    return using(new NavigableSetSubsetTestSetGenerator<E>(delegate, to, from));
  }

  /** Create a suite whose maps are descending views of other maps. */
  private TestSuite createDescendingSuite(
      FeatureSpecificTestSuiteBuilder<?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>>
          parentBuilder) {

import java.util.NoSuchElementException;
import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of the {@code Iterator} interface for sequences
 * whose next element can always be derived from the previous element. Null elements are not
 * supported, nor is the {@link #remove()} method.
 *
 * <p>Example:
 *
 * {@snippet :
 * Iterator<Integer> powersOfTwo =