@ExtendWith(MockitoExtension.class)
class NegotiateContextResponseTest {

    @Mock
    private Configuration mockConfig;

    @Nested
    @DisplayName("PreauthIntegrityNegotiateContext Tests")
    class PreauthIntegrityNegotiateContextTest {

        private PreauthIntegrityNegotiateContext context;
        private byte[] testSalt;
        private int[] testHashAlgos;

        @BeforeEach
        void setUp() {

import org.codelibs.fess.util.ComponentUtil;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;

public class SearchEngineClientRebuildTest extends UnitFessTestCase {

    private TestSearchEngineClient testClient;

    private Set<String> allTargetPrefixes() {
        return Set.of("fess_config", "fess_user", "fess_log");
    }

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {

import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;

/**
 * Test class for NetShareEnum
 */
class NetShareEnumTest {

    @Mock
    private Configuration mockConfig;

    private NetShareEnum netShareEnum;
    private Configuration realConfig;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);
        // Use real configuration for most tests

 * limitations under the License.
 */

package gradlebuild.docs.dsl.docbook;

import gradlebuild.docs.dsl.docbook.model.ClassDoc;

public class ClassDocCommentBuilder {
    private final JavadocConverter javadocConverter;
    private final GenerationListener listener;

    public ClassDocCommentBuilder(JavadocConverter javadocConverter, GenerationListener listener) {
        this.javadocConverter = javadocConverter;

import jcifs.dcerpc.msrpc.samr.SamrSamArray;

/**
 * Tests for {@link MsrpcEnumerateAliasesInDomain}.
 */
class MsrpcEnumerateAliasesInDomainTest {

    @Mock
    private SamrDomainHandle mockDomainHandle;

    @Mock
    private SamrSamArray mockSamArray;

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

    /**
     * Test method for

    // Mocks to inject into toolchainManager
    @Mock
    private Logger logger;

    private ToolchainManagerFactory.DefaultToolchainManagerV3 toolchainManager;

    @Mock
    private ToolchainFactory toolchainFactoryBasicType;

    @Mock
    private ToolchainFactory toolchainFactoryRareType;

    @Mock
    private Lookup lookup;

    @BeforeEach
    void onSetup() throws Exception {

 */
public class IngestFactory {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(IngestFactory.class);

    /** Array of registered ingesters, sorted by priority */
    private Ingester[] ingesters = {};

    /**
     * Default constructor.
     */
    public IngestFactory() {
        // Default constructor
    }

import org.codelibs.fess.opensearch.log.bsentity.BsFavoriteLog;

/**
 * @author FreeGen
 */
public class FavoriteLog extends BsFavoriteLog implements SearchLogEvent {

    private static final long serialVersionUID = 1L;

    private Map<String, Object> fields;

    @Override
    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);

import okhttp3.Response;
import okhttp3.WebSocketListener;

/** A realtime messaging session. */
public final class RtmSession extends WebSocketListener implements Closeable {
  private final SlackApi slackApi;

  /** Guarded by this. */
  private WebSocket webSocket;

  public RtmSession(SlackApi slackApi) {
    this.slackApi = slackApi;
  }

  public void open(String accessToken) throws IOException {

 */
@NullUnmarked
public class LazyStackTraceBenchmark {
  @Param({"20", "200", "2000"})
  int stackDepth;

  @Param({"-1", "3", "15"})
  int breakAt;

  int recursionCount;

  private static final Object duh = new Object();

  @Param Mode mode;

  enum Mode {
    LAZY_STACK_TRACE {
      @Override
      List<StackTraceElement> getStackTrace(Throwable t) {
        return lazyStackTrace(t);