* behaviour. The tests cover flag manipulation, byte‑buffer operations and
 * static helpers. Edge cases such as null or short arrays and negative
 * values are verified to ensure proper exception handling and byte
 * conversion.
 */
@ExtendWith(MockitoExtension.class)
class NtlmMessageTest {

    /** Lightweight concrete implementation used only for testing. */

 */
package org.codelibs.fess.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.io.ResourceUtil;
import org.codelibs.fess.exception.GsaConfigException;
import org.codelibs.fess.helper.SystemHelper;

                } else if (logger.isDebugEnabled()) {
                    logger.debug("No KeyMatch boost docs");
                }

                waitForNext();
            } catch (final Exception e) {
                logger.warn("Failed to load KeyMatch: id={}, term={}", keyMatch.getId(), keyMatch.getTerm(), e);
            }
        });
        this.keyMatchQueryMap = keyMatchQueryMap;

    private final Callable<T> delegate;

    WrappedCallable(Callable<T> delegate) {
      this.delegate = delegate;
    }

    @Override
    public T call() throws Exception {
      return delegate.call();
    }
  }

  private static final class WrappedRunnable implements Runnable {
    private final Runnable delegate;

    WrappedRunnable(Runnable delegate) {

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

import kotlin.reflect.KClass
import okio.IOException
import okio.Timeout

/**
 * A call is a request that has been prepared for execution. A call can be canceled. As this object
 * represents a single request/response pair (stream), it cannot be executed twice.
 */
interface Call : Cloneable {

    try {
      SignedBytes.checkedCast(value);
      fail("Cast to byte should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertWithMessage("%s not found in exception text: %s", value, ex.getMessage())
          .that(ex.getMessage().contains(String.valueOf(value)))
          .isTrue();
    }
  }

  public void testCompare() {
    for (byte x : VALUES) {

            // Single zero should not be compressed
            assertEquals("2001:db8:1:0:2:3:4:5", method.invoke(null, "2001:0db8:1:0:2:3:4:5"));
        } catch (Exception e) {
            // If reflection fails, skip this test
        }
    }

    @Test
    public void testIsIPv6Address() {
        // IPv6 addresses
        assertTrue(IpAddressUtil.isIPv6Address("::1"));

And in many cases, reading them would be a blocking operation (that could block the event loop), because they are read from disk or from the network.

/// info

The example above is actually an exception, because the `io.BytesIO` object is already in memory, so reading it won't block anything.

But in many cases reading a file or a file-like object would block.

///

public class PagerCreatorTest extends UnitFessTestCase {

    private PagerCreator pagerCreator;
    private NamingConvention namingConvention;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        namingConvention = new MockNamingConvention();
        pagerCreator = new PagerCreator(namingConvention);
    }

    // Test constructor initialization
    @Test

  @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
  protected final boolean supportsValuesHashCode(Map<K, V> map) {
    // get the first non-null value
    Collection<V> values = map.values();
    for (V value : values) {
      if (value != null) {
        try {
          int unused = value.hashCode();
        } catch (Exception e) { // sneaky checked exception
          return false;
        }