// When
            int size = chunk.size();

            // Then
            assertEquals(EXPECTED_SIZE, size);
        }

        @ParameterizedTest
        @DisplayName("Should return same size regardless of values")
        @CsvSource({ "0, 0, 0", "1024, 2048, 4096", "9223372036854775807, 9223372036854775807, 2147483647", "-1, -1, -1" })
        void testSizeIsConstant(long sourceOffset, long targetOffset, int length) {

        return facadeSelectList(createCB(cbLambda));
    }

    public PagingResultBean<SearchLog> selectPage(CBCall<SearchLogCB> cbLambda) {
        // #pending same?
        return (PagingResultBean<SearchLog>) facadeSelectList(createCB(cbLambda));
    }

    public void selectCursor(CBCall<SearchLogCB> cbLambda, EntityRowHandler<SearchLog> entityLambda) {

private key for their own certificate. The chain served by a server doesn't need the root
certificate.

The trusted roots don't need to be the same for client and server when using client authentication.
Clients might rely on the platform certificates and servers might use a private
organization-specific certificate authority.

  }

  /**
   * This test creates a long random sequence of inputs, then a lot of differently configured sinks
   * process it; all should produce the same answer, the only difference should be the number of
   * process()/processRemaining() invocations, due to alignment.
   */
  @AndroidIncompatible // slow. TODO(cpovirk): Maybe just reduce iterations under Android.

 * the access mask of the ACE, the access check is successful. Otherwise,
 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file
 * with desired access bits <code>0x00000003</code> (<code>FILE_READ_DATA |

      fun createFormData(
        name: String,
        value: String,
      ): Part = createFormData(name, null, value.toRequestBody())

      @JvmStatic
      fun createFormData(
        name: String,
        filename: String?,
        body: RequestBody,
      ): Part {
        val disposition =
          buildString {
            append("form-data; name=")
            appendQuotedString(name)

	// Essentially the same as S3Select barring the xml name.
	if start.Name.Local == selectParamsXMLName {
		start.Name = xml.Name{Space: "", Local: "SelectRequest"}
	}
	return sp.S3Select.UnmarshalXML(d, start)
}

// RestoreObjectRequest - xml to restore a transitioned object
type RestoreObjectRequest struct {

by _GoStringPtr. Note that the string contents may not have a trailing
NUL byte.

As Go doesn't have support for C's union type in the general case,
C's union types are represented as a Go byte array with the same length.

Go structs cannot embed fields with C types.

Go code cannot refer to zero-sized fields that occur at the end of
non-empty C structs. To get the address of such a field (which is the

    return requireNonNull(values);
  }

  /*
   * The following methods are safe to call as long as the conditions in the *previous* comment are
   * met *and* the index is less than size().
   *
   * (The above explains when these methods are safe from a `nullness` perspective. From an
   * `unchecked` perspective, they're safe because we put only K/V elements into each array.)
   */

  @SuppressWarnings("unchecked")

	if err != nil {
		t.Fatalf("got %v, expected nil", err)
	}
	zh := zf.File[0].FileHeader
	if zh.Name != h.Name || zh.Method != h.Method || zh.UncompressedSize64 != uint64(len("hi")) {
		t.Fatalf("got %q/%d/%d expected %q/%d/%d", zh.Name, zh.Method, zh.UncompressedSize64, h.Name, h.Method, len("hi"))
	}
}

// Issue 4302.
func TestHeaderInvalidTagAndSize(t *testing.T) {