final Type t = new TypeToken<T>(getClass()) {}.getType();
    final Type array = new TypeToken<T[]>(getClass()) {}.getType();
  }

  public void testGenericArrayType() {
    GenericArray<?> genericArray = new GenericArray<>();
    assertEquals(GenericArray.class.getTypeParameters()[0], genericArray.t);
    assertEquals(Types.newArrayType(genericArray.t), genericArray.array);
  }

  public void testClassWrapper() {

{"name": "Plumbus", "description": "A multi-purpose household device."}
{"name": "Portal Gun", "description": "A portal opening device."}
{"name": "Meeseeks Box", "description": "A box that summons a Meeseeks."}
```

Es ist einem JSON-Array (entspricht einer Python-Liste) sehr ähnlich, aber anstatt in `[]` eingeschlossen zu sein und `,` zwischen den Elementen zu haben, gibt es hier **ein JSON-Objekt pro Zeile**, sie sind durch ein Zeilenumbruchzeichen getrennt.

        securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        assertEquals(0x8004, securityDescriptor.getType());
    }

    @Test
    @DisplayName("Test getAces returns correct ACE array")
    void testGetAces() throws SMBProtocolDecodingException {
        prepareSecurityDescriptorBufferWithDACL(testBuffer, 0, 3);

        securityDescriptor.decode(testBuffer, 0, testBuffer.length);

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.Sets;
import com.google.common.testing.NullPointerTester;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

        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 {

Zum Beispiel deklariert das obige Modell ein JSON „`object`“ (oder Python-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr>) wie dieses:

```JSON
{
    "name": "Foo",
    "description": "An optional description",
    "price": 45.2,
    "tax": 3.5
}
```

Observe como `Offer` tem uma lista de `Item`s, que por sua vez têm uma lista opcional de `Image`s

///

## Corpos de listas puras { #bodies-of-pure-lists }

Se o valor de primeiro nível do corpo JSON que você espera for um `array` do JSON (uma` lista` do Python), você pode declarar o tipo no parâmetro da função, da mesma forma que nos modelos do Pydantic:

```Python
images: list[Image]
```

como em:

        // Verify that suppression is disabled
        try {
            exception.addSuppressed(new Exception("Test suppressed"));
            // If suppression is disabled, getSuppressed should return empty array
            assertEquals(0, exception.getSuppressed().length);
        } catch (Exception e) {
            // If an exception is thrown when trying to add suppressed, that's also valid

        assertTrue(infoString.contains("bytesPerSect=512"), "toString should contain bytesPerSect");
    }

    // Helper methods to write numbers to byte array in little-endian format.
    private void writeInt2(int val, byte[] dst, int dstIndex) {
        dst[dstIndex++] = (byte) val;
        dst[dstIndex++] = (byte) (val >> 8);
    }

   * reported {@link Spliterator#SUBSIZED}. This is generally the case if the underlying stream
   * comes from a data structure supporting efficient indexed random access, typically an array or
   * list.
   *
   * <p>The order of the resulting stream is defined if and only if the order of the original stream
   * was defined.
   */