import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;

/** Forwarding wrapper around a {@code Condition}. */
@J2ktIncompatible
@ElementTypesAreNonnullByDefault
abstract class ForwardingCondition implements Condition {
  abstract Condition delegate();

  @Override
  public void await() throws InterruptedException {
    delegate().await();
  }

  @Override

 */

package jcifs.smb1.smb1;

import java.io.Serializable;

import jcifs.smb1.UniAddress;
import jcifs.smb1.util.Hexdump;

public final class NtlmChallenge implements Serializable {

    public byte[] challenge;
    public UniAddress dc;

    NtlmChallenge( byte[] challenge, UniAddress dc ) {
        this.challenge = challenge;
        this.dc = dc;
    }

import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * Simple base class to verify that we handle generics correctly.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'

import org.apache.logging.log4j.Logger;
import org.lastaflute.core.direction.CurtainFinallyHook;
import org.lastaflute.core.direction.FwAssistantDirector;

/**
 * @author jflute
 */
public class FessCurtainFinallyHook implements CurtainFinallyHook {

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

    @Override
    public void hook(final FwAssistantDirector assistantDirector) {

package org.gradle.test

import org.gradle.test.sub2.GroovyInterface

class GroovyClassWithInnerTypes implements GroovyInterface {
    /**
     * This is an inner enum.
     */
    enum InnerEnum {}

    /**
     * This is an inner class.
     */
    static class InnerClass {
        InnerEnum enumProp

        /**
         * This is an inner inner class.
         */
        class AnotherInner {

| Maximum number of versions per object                                           | 10000 (can be configured to higher values but we do not recommend beyond 10000) |

name: Feature request
about: Suggest an idea
title: ''
labels: enhancement
assignees: ''

---

Start by telling us what problem you’re trying to solve. Often a solution already exists!

 *
 * @author Kevin Bourrillion
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
abstract class AbstractMapBasedMultiset<E extends @Nullable Object> extends AbstractMultiset<E>
    implements Serializable {

  transient ObjectCountHashMap<E> backingMap;
  transient long size;

  AbstractMapBasedMultiset(int distinctElements) {
    backingMap = newBackingMap(distinctElements);
  }

 * under the License.
 */
package org.apache.maven.repository;

import org.apache.maven.artifact.handler.ArtifactHandler;

/**
 * Assists unit testing.
 *
 */
@Deprecated
class TestArtifactHandler implements ArtifactHandler {

    private String type;

    private String extension;

    public TestArtifactHandler(String type) {
        this(type, type);
    }

 * {@link #sloppyTearDown()} instead.
 *
 * @author Luiz-Otavio Zorzella
 * @since 10.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class SloppyTearDown implements TearDown {
  private static final Logger logger = Logger.getLogger(SloppyTearDown.class.getName());

  @Override
  public final void tearDown() {
    try {
      sloppyTearDown();
    } catch (Throwable t) {