sb.setLength(0); // Reset length
        }
        return sb;
    }

    private void returnStringBuilder(StringBuilder sb) {
        if (sb != null && sb.capacity() < 2048) { // Avoid keeping very large builders
            stringBuilderPool.offer(sb);
        }
    }

    private Map<String, Object> getContextMap() {
        HashMap<String, Object> map = mapPool.poll();
        if (map == null) {

  private lateinit var client: OkHttpClient
  private lateinit var host: String
  private lateinit var url: HttpUrl
  private val networkLogs = LogRecorder()
  private val networkInterceptor = HttpLoggingInterceptor(networkLogs)
  private val applicationLogs = LogRecorder()
  private val applicationInterceptor = HttpLoggingInterceptor(applicationLogs)
  private var extraNetworkInterceptor: Interceptor? = null

                                            <la:hidden property="sessionId"/></td>
                                    </tr>
                                    <c:forEach var="info" items="${crawlingInfoParamItems}">
                                        <tr>
                                            <th>${f:h(info.keyMsg)}</th>
                                            <td>${f:h(info.value)}</td>

import okio.fakefilesystem.FakeFileSystem
import org.junit.AssumptionViolatedException
import org.junit.Before
import org.junit.Test

abstract class BaseOkHttpClientUnitTest {
  private lateinit var client: OkHttpClient

  @Before
  fun setUp() {
    client =
      OkHttpClient
        .Builder()
        .cache(Cache(FakeFileSystem(), "/cache".toPath(), 10_000_000))
        .build()
  }

  @Test

						key="labels.index_lang"
					/></label>
				<div class="col-lg-5 col-md-8 col-sm-7 col-6">
					<la:select property="lang" styleId="langSearchOption" multiple="true" styleClass="form-control">
						<c:forEach var="item" items="${langItems}">
							<la:option value="${f:u(item.value)}">${f:h(item.label)}</la:option>
						</c:forEach>
					</la:select>
				</div>
			</div>
			<c:if test="${displayLabelTypeItems}">

                                <table class="table table-bordered" aria-label="<la:message key="labels.search_log_details" />">
                                    <tbody>
                                    <c:forEach var="info" items="${logParamItems}">
                                        <tr>
                                            <th style="width: 25%">${f:h(info.key)}</th>
                                            <c:choose>

        assertEquals("short", result);
    }

    @Test
    void testReadStringWithMaxLengthExceeded() {
        smb.useUnicode = false;
        byte[] buffer = "a very long string that exceeds max length".getBytes();
        assertThrows(RuntimeException.class, () -> {
            smb.readString(buffer, 0, 10, false);
        });
    }

    @Test
    void testEncodeDecode() {

   * thus a motivated caller may be able to expose the reference to another thread that would then
   * call cancel() and be unable to cancel the delegate.
   * There are a number of ways to solve this, none of which are very pretty, and it is currently
   * believed to be a purely theoretical problem (since the other actions should supply sufficient
   * write-barriers).
   */

  @LazyInit private @Nullable ListenableFuture<V> delegateRef;

        }

        @Test
        void testGetInputStream() throws IOException {
            // Act
            var inputStream = smbFile.getInputStream();

            // Assert
            assertNotNull(inputStream);
            verify(smbFile).openUnshared(0, // SmbConstants.O_RDONLY = 0x01, but SmbFileInputStream uses 0

  private val windows = subject.windows

  @TempDir
  lateinit var cacheDirFile: File
  private val cacheDir: Path
    get() =
      when (baseFilesystem) {
        is FakeFileSystem -> "/cache".toPath()
        else -> cacheDirFile.path.toPath()
      }
  private val appVersion = 100
  private lateinit var journalFile: Path
  private lateinit var journalBkpFile: Path
  private val taskFaker = TaskFaker()