assertEquals("user2", ((SID) resolvedFirst[1]).acctName);

        // Second call with overlap should use cache for s2 and s3, requiring only s3 if not cached
        // Mark s3 unresolved to force resolve of one element
        doAnswer(inv -> {
            SID[] toResolve = inv.getArgument(2);
            for (SID s : toResolve) {
                s.type = jcifs.SID.SID_TYPE_USER;
                s.domainName = "DOM";

   |-->
  <mirrors>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>

     * Return an array of Access Control Entry (ACE) objects representing
     * the security descriptor associated with this file or directory.
     * If no DACL is present, null is returned. If the DACL is empty, an array with 0 elements is returned.
     *
     * @param resolveSids
     *            Attempt to resolve the SIDs within each ACE form
     *            their numeric representation to their corresponding account names.

{* ../../docs_src/python_types/tutorial007_py310.py hl[1] *}

Das bedeutet:

* Die Variable `items_t` ist ein `tuple` mit 3 Elementen, einem `int`, einem weiteren `int` und einem `str`.
* Die Variable `items_s` ist ein `set`, und jedes seiner Elemente ist vom Typ `bytes`.

#### Dict { #dict }

Um ein `dict` zu definieren, übergeben Sie zwei Typ-Parameter, getrennt durch Kommas.

### Validierung { #validation }

* Validierung für die meisten (oder alle?) Python-**Datentypen**, hierzu gehören:
    * JSON Objekte (`dict`).
    * JSON Listen (`list`), die den Typ ihrer Elemente definieren.
    * Strings (`str`) mit definierter minimaler und maximaler Länge.
    * Zahlen (`int`, `float`) mit Mindest- und Maximalwerten, usw.

* Validierung für mehr exotische Typen, wie:
    * URL.

package jcifs.smb1.smb1;

import jcifs.smb1.util.Hexdump;

/**
 * An Access Control Entry (ACE) is an element in a security descriptor
 * such as those associated with files and directories. The Windows OS
 * determines which users have the necessary permissions to access objects
 * based on these entries.
 * <p>
 * To fully understand the information exposed by this class a description

        jcifs.SID mockSid2 = mock(jcifs.SID.class);
        when(mockSid1.unwrap(sid_t.class)).thenReturn(mockSidT);
        // Don't stub mockSid2 since it won't be reached due to NPE on null element
        testSids = new jcifs.SID[] { mockSid1, null, mockSid2 };

        // Act & Assert - This should throw an exception when LsarSidArrayX tries to process null
        assertThrows(NullPointerException.class, () -> {

  // TODO(user): Write more tests for memory retention.
  @ForOverride
  @OverridingMethodsMustInvokeSuper
  void releaseResources(ReleaseResourcesReason reason) {
    checkNotNull(reason);
    /*
     * All elements of `futures` are completed, or this future has already completed and read
     * `futures` into a local variable (in preparation for propagating cancellation to them). In

    /**
     * This default mode for combining children DOMs during merge means that where element names match, the process will
     * try to merge the element data, rather than putting the dominant and recessive elements (which share the same
     * element name) as siblings in the resulting DOM.
     */
    @Deprecated(since = "4.0.0", forRemoval = true)

			results = append(results, p.Interface())
		} else if rv.IsValid() {
			results = append(results, rv.Interface())
		}
	}

	// Process each argument; if an argument is a slice/array, expand its elements
	for _, value := range values {
		rv := reflect.ValueOf(value)
		if rv.Kind() == reflect.Slice || rv.Kind() == reflect.Array {
			for i := 0; i < rv.Len(); i++ {
				appendToResult(rv.Index(i))
			}
		} else {