@Test
        @DisplayName("Should read valid structure with size 4")
        void testReadBytesWireFormatValidStructure() throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[10];
            int bufferIndex = 0;
            SMBUtil.writeInt2(4, buffer, bufferIndex); // Write structure size = 4
            SMBUtil.writeInt2(0, buffer, bufferIndex + 2); // Reserved field

        final Map<String, Object> searchBody = new HashMap<>();
        searchBody.put("size", 100);

        String response = checkMethodBase(searchBody).get(API_PATH + "/logs").asString();
        List<Map<String, Object>> logs = JsonPath.from(response).getList("response.logs");

        logger.info("Failure URL logs: {}", logs);
        assertTrue(logs.size() > 0, "Should have at least one failure URL log");

    @Test
    @DisplayName("Test size returns positive message size")
    void testSizeReturnsPositiveValue() {
        // Given
        int expectedSize = 1024;
        when(request.size()).thenReturn(expectedSize);

        // When
        int result = request.size();

        // Then
        assertEquals(expectedSize, result);
        verify(request, times(1)).size();
    }

    @Test

    // When called at high frequency, boxing size generates too much garbage,
    // so avoid doing that if we can.
    checkArgument(size >= 0, "Invalid size: %s", size);
    return newDataOutput(new ByteArrayOutputStream(size));
  }

  /**
   * Returns a new {@link ByteArrayDataOutput} instance which writes to the given {@code

		// is `10000`.
		switch {
		case b >= '0' && b <= '9':
			size = size<<4 | int(b-'0')
		case b >= 'a' && b <= 'f':
			size = size<<4 | int(b-('a'-10))
		case b >= 'A' && b <= 'F':
			size = size<<4 | int(b-('A'-10))
		default:
			cr.err = errMalformedEncoding
			return n, cr.err
		}
		if size > maxChunkSize {
			cr.err = errChunkTooBig
			return n, cr.err
		}
	}

    }

    /**
     * Gets the page size for pagination.
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size for pagination.
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {

        "cache-control",
        "no-store",
        "user-agent",
        "OkHttp",
      )
    val headerMap = headers.toMultimap()
    assertThat(headerMap["cache-control"]!!.size).isEqualTo(2)
    assertThat(headerMap["user-agent"]!!.size).isEqualTo(1)
  }

  @Test fun toMultimapUsesCanonicalCase() {
    val headers =
      Headers.headersOf(
        "cache-control",
        "no-store",

  private var contentLength = -1L

  @get:JvmName("boundary")
  val boundary: String
    get() = boundaryByteString.utf8()

  /** The number of parts in this multipart body. */
  @get:JvmName("size")
  val size: Int
    get() = parts.size

  fun part(index: Int): Part = parts[index]

  override fun isOneShot(): Boolean = parts.any { it.body.isOneShot() }

  /** A combination of [type] and [boundaryByteString]. */

        final int size = docs.size();
        if (size == 0) {
            return docs; // empty
        }
        int fromIndex = startPosition;
        if (fromIndex >= size) {
            fromIndex = size - 1;
        }
        int toIndex = startPosition + pageSize;
        if (toIndex >= size) {
            toIndex = size;
        }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    // this loop is faster for RandomAccess instances, which ImmutableLists are
    int size = size();
    for (int i = 0; i < size; i++) {
      dst[offset + i] = get(i);
    }
    return offset + size;
  }

  /**
   * Returns a view of this immutable list in reverse order. For example, {@code ImmutableList.of(1,