public void testSuccessfulForwarding() {
    ForwardingObjectTester.testForwardingObject(ForwardToDelegate.class);
  }

  private abstract static class FailToForward extends ForwardingObject implements Runnable {
    @Override
    public void run() {}
  }

  private abstract static class ForwardToDelegate extends ForwardingObject implements Runnable {
    @Override
    public void run() {
      delegate().run();

 */
package jcifs.pac;

/**
 * Structure representing the PAC_CREDENTIAL_TYPE record
 *
 * @author jbbugeau
 */
public class PacCredentialType {

    private static final int MINIMAL_BUFFER_SIZE = 32;

    private final byte[] credentialType;

    /**
     * Constructs a PAC credential type from raw data.
     * @param data the raw credential type data

 */
@Deprecated(since = "4.0.0")
class DefaultSettingsBuildingResult implements SettingsBuildingResult {

    private Settings effectiveSettings;

    private List<SettingsProblem> problems;

    DefaultSettingsBuildingResult(Settings effectiveSettings, List<SettingsProblem> problems) {
        this.effectiveSettings = effectiveSettings;

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.util.DfTypeUtil;

/**
 * @author FreeGen
 */
public class ClickLogBhv extends BsClickLogBhv {
    private static final Logger logger = LogManager.getLogger(ClickLogBhv.class);

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {

 */
public class WitnessUnregisterResponse {
    /**
     * Creates a new witness unregister response.
     */
    public WitnessUnregisterResponse() {
        // Default constructor
    }

    private int returnCode;
    private String error;

    /**
     * Checks if the unregistration was successful.
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return returnCode == 0;

/**
 * RDMA credit management for flow control.
 *
 * Credits are used to control the flow of messages between
 * RDMA peers to prevent buffer overflow.
 */
public class RdmaCredits {

    private int initialCredits;
    private int creditsGranted;

    /**
     * Create new RDMA credits manager
     */
    public RdmaCredits() {
        this.initialCredits = RdmaCapabilities.DEFAULT_SEND_CREDIT_TARGET;

import jcifs.dcerpc.msrpc.MsrpcEnumerateAliasesInDomain;
import jcifs.dcerpc.msrpc.SamrDomainHandle;
import jcifs.dcerpc.msrpc.samr;

class MsrpcEnumerateAliasesInDomainTest {

    @Mock
    private SamrDomainHandle mockDomainHandle;
    @Mock
    private samr.SamrSamArray mockSamArray;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test

 */
@Deprecated(since = "4.0.0")
public class DefaultToolchainsBuildingResult implements ToolchainsBuildingResult {

    private PersistedToolchains effectiveToolchains;

    private List<Problem> problems;

    /**
     * Default constructor
     *
     * @param effectiveToolchains the merged toolchains, may not be {@code null}

import okhttp3.WebSocket
import okhttp3.WebSocketListener
import okhttp3.internal.platform.Platform
import okio.ByteString

class WebSocketRecorder(
  private val name: String,
) : WebSocketListener() {
  private val events = LinkedBlockingQueue<Any>()
  private var delegate: WebSocketListener? = null

  /** Sets a delegate for handling the next callback to this listener. Cleared after invoked.  */

    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestDeque<E> implements Deque<E> {
    private final Deque<E> delegate = new LinkedList<>();
    private final Object mutex = new Object[0]; // something Serializable

    @Override
    public boolean offer(E o) {
      assertTrue(Thread.holdsLock(mutex));