* Gets the total content size of all documents in this list.
     *
     * @return the total content size in bytes
     */
    public long getContentSize() {
        return contentSize;
    }

    /**
     * Adds to the total content size of this document list.
     *
     * @param contentSize the content size to add in bytes
     */
    public void addContentSize(final long contentSize) {
        this.contentSize += contentSize;

        * In responses, the `set` will be converted to a `list`.
        * The generated schema will specify that the `set` values are unique (using JSON Schema's `uniqueItems`).
* `bytes`:
    * Standard Python `bytes`.
    * In requests and responses will be treated as `str`.
    * The generated schema will specify that it's a `str` with `binary` "format".
* `Decimal`:
    * Standard Python `Decimal`.

        * En responses, el `set` se convertirá en una `list`.
        * El esquema generado especificará que los valores del `set` son únicos (usando `uniqueItems` de JSON Schema).
* `bytes`:
    * `bytes` estándar de Python.
    * En requests y responses se tratará como `str`.
    * El esquema generado especificará que es un `str` con "binary" como "format".
* `Decimal`:
    * `Decimal` estándar de Python.

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
	"strings"
)

var (
	keyFile  string
	certFile string
)

func init() {

      @Throws(IOException::class)
      override fun write(
        source: Buffer,
        byteCount: Long,
      ) {
        val bytes = source.readByteString(byteCount)
        delegate.write(
          Buffer()
            .write(bytes.toAsciiUppercase()),
          byteCount,
        )
      }
    }

            // Then
            assertEquals(2, bytesRead, "Should read 2 bytes");
            assertTrue(response.isSupportSearchBits(), "Should decode search bits flag");
            assertTrue(response.isShareDfs(), "Should decode DFS flag");
        }

        @Test
        @DisplayName("Should decode bytes correctly")
        void testReadBytesWireFormat() throws Exception {

            // Verify that inputBuffer.encode was called
            verify(mockInputBuffer).encode(any(byte[].class), anyInt());

            // Verify total bytes written
            assertEquals(90, bytesWritten); // 40 bytes header + 50 bytes input buffer
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @ParameterizedTest

        }
    }

    @Test
    void testConstructorWithLongKey() throws NoSuchAlgorithmException {
        // Test constructor with a key longer than BLOCK_LENGTH (64 bytes)
        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            HMACT64 hmac = new HMACT64(LONG_TEST_KEY);

   */
  public static CharSource asCharSource(URL url, Charset charset) {
    return asByteSource(url).asCharSource(charset);
  }

  /**
   * Reads all bytes from a URL into a byte array.
   *
   * @param url the URL to read from
   * @return a byte array containing all the bytes from the URL
   * @throws IOException if an I/O error occurs
   */
  public static byte[] toByteArray(URL url) throws IOException {

 * limitations under the License.
 */
package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged