int logFloor = x.bitLength() - 1;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x)); // fall through
      case DOWN:
      case FLOOR:
        return logFloor;

      case UP:
      case CEILING:
        return isPowerOfTwo(x) ? logFloor : logFloor + 1;

      case HALF_DOWN:
      case HALF_UP:
      case HALF_EVEN:
        if (logFloor < SQRT2_PRECOMPUTE_THRESHOLD) {

import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.runner.Description
import org.junit.runners.model.Statement

@Suppress("deprecation")
@Timeout(30)
@Tag("Slow")
class MockWebServerTest {
  @RegisterExtension
  var platform = PlatformRule()
  private val server = MockWebServer()

  @BeforeEach
  fun setUp() {
    server.start()
  }

  @AfterEach
  fun tearDown() {

import okio.Buffer
import okio.ByteString.Companion.encodeUtf8
import okio.GzipSink
import okio.Source
import okio.buffer
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class CompressionInterceptorTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  val source =
    Buffer().apply {
      write("Hello World".encodeUtf8())
    } as Source

  @Test

 *     assertEquals("some message", firstRecord.getMessage());
 *   }
 * </pre>
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@GwtCompatible
@NullMarked
public class TestLogHandler extends Handler {
  private final Object lock = new Object();

  /** We will keep a private list of all logged records */
  @GuardedBy("lock")
  private final List<LogRecord> list = new ArrayList<>();

import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSContext;
import jcifs.NameServiceClient;
import jcifs.NetbiosAddress;
import jcifs.config.BaseConfiguration;

@ExtendWith(MockitoExtension.class)
class NbtAddressTest {

    private Name mockName;
    @Mock
    private CIFSContext mockContext;
    @Mock
    private NameServiceClient mockNameServiceClient;
    @Mock
    private BaseConfiguration mockConfig;

          e: IOException,
        ) {
          exceptionRef.set(e)
          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()

        assertTrue(output.contains("42"));
        assertTrue(output.contains("true"));

        // Test close
        logStream.close();
        // After close, the stream should not accept more writes
        // but PrintStream doesn't throw exceptions on write after close
    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety of getInstance

## Classe de resposta personalizada

Você pode criar sua própria classe de resposta, herdando de `Response` e usando essa nova classe.

Por exemplo, vamos supor que você queira utilizar o <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, mas com algumas configurações personalizadas que não estão incluídas na classe `ORJSONResponse`.

import org.codelibs.core.net.URLUtil;

/**
 * Utility class for handling {@link java.util.jar.JarFile}.
 *
 * @author higa
 */
public abstract class JarFileUtil {

    /**
     * Do not instantiate.
     */
    protected JarFileUtil() {
    }

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

    /**

import java.util.Map;

import javax.security.auth.kerberos.KerberosKey;

import jcifs.pac.PACDecodingException;

/**
 * Abstract base class for Kerberos authorization data.
 * This class provides parsing capabilities for different types of Kerberos authorization data.
 */
public abstract class KerberosAuthData {

    /**
     * Default constructor for KerberosAuthData.
     */
    protected KerberosAuthData() {