case '\\':
                sb.append("\\5c");
                break;
            case '*':
                sb.append("\\2a");
                break;
            case '(':
                sb.append("\\28");
                break;
            case ')':
                sb.append("\\29");
                break;
            case '\0':
                sb.append("\\00");
                break;
            default:

        Encdec.enc_uint32le(0x00000000, temp, 24); // Unknown
        if (avPairs != null) {
            System.arraycopy(avPairs, 0, temp, 28, avPairsLength);
        }
        Encdec.enc_uint32le(0x00000000, temp, 28 + avPairsLength); // mystery bytes!

        return NtlmUtil.computeResponse(responseKeyNT, serverChallenge, temp, 0, temp.length);
    }

    /**

        Trans2QueryFSInformationResponse response =
                new Trans2QueryFSInformationResponse(Trans2QueryFSInformationResponse.SMB_QUERY_FS_SIZE_INFO);
        byte[] buffer = new byte[28];
        // Mock data for SmbQueryFSSizeInfo
        writeInt8(2000, buffer, 0); // total allocation units
        writeInt8(1000, buffer, 8); // free allocation units

            assertTrue(bytesRead > 0);
            // readDataWireFormat returns bytes consumed from header, not full buffer
            assertEquals(28, bytesRead); // Header + one referral structure
            assertNotNull(response.getDfsResponse());
        }

        @Test
        @DisplayName("Should handle readDataWireFormat with offset")

import okhttp3.Request
import okhttp3.internal.platform.Platform
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.parallel.Isolated

@Isolated
@SdkSuppress(minSdkVersion = 28)
class StrictModeTest {
  private val violations = mutableListOf<Violation>()

  @AfterEach
  fun cleanup() {
    StrictMode.setThreadPolicy(
      ThreadPolicy
        .Builder()
        .permitAll()

	_ = x[storageMetricReadAll-23]
	_ = x[storageMetricStatInfoFile-24]
	_ = x[storageMetricReadMultiple-25]
	_ = x[storageMetricDeleteAbandonedParts-26]
	_ = x[storageMetricDiskInfo-27]
	_ = x[storageMetricDeleteBulk-28]
	_ = x[storageMetricRenamePart-29]
	_ = x[storageMetricReadParts-30]
	_ = x[storageMetricLast-31]
}

            assertEquals(1, Integer.numberOfTrailingZeros(ACE.FILE_WRITE_DATA), "FILE_WRITE_DATA should be at bit position 1");
            assertEquals(28, Integer.numberOfTrailingZeros(ACE.GENERIC_ALL), "GENERIC_ALL should be at bit position 28");
            assertEquals(31, Integer.numberOfTrailingZeros(ACE.GENERIC_READ), "GENERIC_READ should be at bit position 31");
        }
    }

    @Nested

    @Test
    public void testExcessiveBufferSizes() {
        byte[] buffer = createBasicNegotiateResponseBuffer();

        // Test excessive maxTransactSize (> 16MB)
        SMBUtil.writeInt4(20 * 1024 * 1024, buffer, 28); // 20MB
        SMBUtil.writeInt4(1024 * 1024, buffer, 32); // 1MB read size - valid
        SMBUtil.writeInt4(1024 * 1024, buffer, 36); // 1MB write size - valid

	if req.Name != s.keyID {
		return DEK{}, ErrKeyNotFound
	}
	associatedData, err := req.AssociatedData.MarshalText()
	if err != nil {
		return DEK{}, err
	}

	const randSize = 28
	random, err := sioutil.Random(randSize)
	if err != nil {
		return DEK{}, err
	}
	iv, nonce := random[:16], random[16:]

	prf := hmac.New(sha256.New, s.key)
	prf.Write(iv)

     * when the escaper is made compliant with RFC 2396, but that's a good thing (just change them
     * to assertUnescaped).
     */
    assertEscaping(e, "%21", '!');
    assertEscaping(e, "%28", '(');
    assertEscaping(e, "%29", ')');
    assertEscaping(e, "%7E", '~');
    assertEscaping(e, "%27", '\'');

    // Plus for spaces
    assertEscaping(e, "+", ' ');
    assertEscaping(e, "%2B", '+');