when(transport.getServerEncryptionKey()).thenReturn(key);
        assertArrayEquals(key, transport.getServerEncryptionKey());
        verify(transport).getServerEncryptionKey();

        // Empty array
        byte[] empty = new byte[0];
        when(transport.getServerEncryptionKey()).thenReturn(empty);
        assertArrayEquals(empty, transport.getServerEncryptionKey());

        // Null

      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {
      // Kotlin native, see above
    }

    // The radix is used as an array index, so try a negative value.
    try {
      UnsignedInts.parseUnsignedInt("0", -1);
      fail();
    } catch (NumberFormatException expected) {
    } catch (IllegalArgumentException expected) {

		wantResult string
		withJSON   string // Override JSON input
	}{
		{
			name:       "select-in-array-full",
			query:      `SELECT * from s3object s WHERE 'bar' IN s.synonyms[*]`,
			wantResult: `{"id":0,"title":"Test Record","desc":"Some text","synonyms":["foo","bar","whatever"]}`,
		},
		{
			name:  "simple-in-array",
			query: `SELECT * from s3object s WHERE s.id IN (1,3)`,

import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.jspecify.annotations.Nullable;

/**
 * An object which joins pieces of text (specified as an array, {@link Iterable}, varargs or even a
 * {@link Map}) with a separator. It either appends the results to an {@link Appendable} or returns
 * them as a {@link String}. Example:
 *
 * {@snippet :

`user_in` ist ein Pydantic-Modell der Klasse `UserIn`.

Pydantic-Modelle haben eine `.model_dump()`-Methode, die ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> mit den Daten des Modells zurückgibt.

Wenn wir also ein Pydantic-Objekt `user_in` erstellen, etwa so:

```Python
user_in = UserIn(username="john", password="secret", email="******@****.***")

      return false;
    }
  }

  private static <X extends Exception> X newWithCause(Class<X> exceptionClass, Throwable cause) {
    // getConstructors() guarantees this as long as we don't modify the array.
    @SuppressWarnings({"unchecked", "rawtypes"})
    List<Constructor<X>> constructors = (List) Arrays.asList(exceptionClass.getConstructors());

        buffer.put((byte) 0x00); // Padding
        buffer.putShort((short) 8); // AclSize
        buffer.putShort((short) 0); // AceCount
        buffer.putShort((short) 0); // Padding

        return buffer.array();
    }

    /**
     * Helper method to set error code using reflection
     */
    private void setErrorCode(NtTransQuerySecurityDescResponse response, int errorCode) throws Exception {

        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        // No exception means success
    }

    @Test
    void testEngineUpdateByteArrayPartial() {
        // Test engineUpdate with partial array
        HMACT64 hmac = new HMACT64(TEST_KEY);
        hmac.engineUpdate(TEST_DATA, 2, TEST_DATA.length - 2);
        // No exception means success
    }

    @Test
    void testEngineReset() {

   * they're defined above -- including logic to add and subtract 1 to map between the values stored
   * in the predecessor/successor arrays and the indexes in the elements array that they identify.
   */

        // Then
        assertEquals(maxData.length, bytesWritten);
    }

    @Test
    @DisplayName("Test zero-length write with valid data array")
    void testZeroLengthWrite() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, 0);
        byte[] dst = new byte[100];

        // When