* governing permissions and limitations under the License.
 */
package org.codelibs.fess.timer;

import org.codelibs.core.timer.TimeoutTarget;
import org.codelibs.fess.unit.UnitFessTestCase;

/**
 * Test class for HotThreadMonitorTarget.
 */
public class HotThreadMonitorTargetTest extends UnitFessTestCase {

    private HotThreadMonitorTarget target;

    @Override

import org.jspecify.annotations.NullMarked;

/**
 * Unit test for {@link ComparisonChain}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public class ComparisonChainTest extends TestCase {
  private static final DontCompareMe DONT_COMPARE_ME = new DontCompareMe();

  private static class DontCompareMe implements Comparable<DontCompareMe> {
    @Override
    public int compareTo(DontCompareMe o) {

import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.Nullable;

/**
 * A TimeLimiter implementation which actually does not attempt to limit time at all. This may be
 * desirable to use in some unit tests. More importantly, attempting to debug a call which is
 * time-limited would be extremely annoying, so this gives you a time-limiter you can easily swap in
 * for your real time-limiter while you're debugging.
 *

    int last = 0;
    for (int shards = 2; shards <= MAX_SHARDS; shards++) {
      int chosen = Hashing.consistentHash(h, shards);
      if (chosen != last) {
        map.incrementAndGet(shards);
        last = chosen;
      }
    }
  }

  private static final int ITERS = 10000;
  private static final int MAX_SHARDS = 500;

        private final byte[] buffer = new byte[20];
        private final int dataCompactionMode = 1;
        private final int dataLength = 1024;
        private final int dataOffset = 54;

        @BeforeEach
        public void setUp() {
            // Build a sample buffer
            int bufferIndex = 0;
            bufferIndex += 2; // reserved

  }

  private static <T> int drain(
      BlockingQueue<T> q,
      Collection<? super T> buffer,
      int maxElements,
      long timeout,
      TimeUnit unit,
      boolean interruptibly)
      throws InterruptedException {
    return interruptibly
        ? Queues.drain(q, buffer, maxElements, timeout, unit)
        : Queues.drainUninterruptibly(q, buffer, maxElements, timeout, unit);

 */
package org.codelibs.fess.auth.chain;

import org.codelibs.fess.ldap.LdapManager;
import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.opensearch.user.exentity.User;
import org.codelibs.fess.unit.UnitFessTestCase;
import org.codelibs.fess.util.ComponentUtil;

public class LdapChainTest extends UnitFessTestCase {

    private LdapChain ldapChain;
    private TestLdapManager testLdapManager;

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

import org.codelibs.fess.unit.UnitFessTestCase;

public class ContentNotFoundExceptionTest extends UnitFessTestCase {

    public void test_constructor_withValidUrls() {
        // Test with normal URLs

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

import org.codelibs.fess.unit.UnitFessTestCase;

public class SsoProcessExceptionTest extends UnitFessTestCase {

    public void test_constructor_withMessage() {
        // Test constructor with message only

        // Given
        int sid = 0x1234;
        int resumeKey = 0x89ABCDEF; // LE expected: EF CD AB 89
        String name = "file.txt";
        Trans2FindNext2 next = new Trans2FindNext2(sid, resumeKey, name);

        int expectedLen = 2 + 2 + 2 + 4 + 2 + name.length() + 1;
        byte[] dst = new byte[expectedLen];

        // When
        int len = next.writeParametersWireFormat(dst, 0);