// Assert - fields preserved
        assertSame(cause, ex.getCause());
        assertEquals(message, ex.getMessage());

        // Since message is explicitly provided, constructor should not need to call methods on cause
        Mockito.verifyNoInteractions(cause);

        // toString should include provided message
        assertEquals(SMBProtocolDowngradeException.class.getName() + ": " + message, ex.toString());
    }

        }
    }

    @Test
    @DisplayName("customizeCreate sets required flags and extended mode")
    void customizeCreateSetsFlagsAndExtended() throws Exception {
        // Arrange: real instance to call protected method; collaborators mocked for interaction verification
        SmbNamedPipe pipe = new SmbNamedPipe("smb://server/IPC$/foo", SmbPipeResource.PIPE_TYPE_RDWR, ctx());

### Tags mittels Enumeration

Wenn Sie eine große Anwendung haben, können sich am Ende **viele Tags** anhäufen, und Sie möchten sicherstellen, dass Sie für verwandte *Pfadoperationen* immer den **gleichen Tag** nehmen.

In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern.

**FastAPI** unterstützt diese genauso wie einfache Strings:

{* ../../docs_src/path_operation_configuration/tutorial002b.py hl[1,8:10,13,18] *}

    return asByteSink(file, modes).asCharSink(charset);
  }

  /**
   * Reads all bytes from a file into a byte array.
   *
   * <p><b>{@link java.nio.file.Path} equivalent:</b> {@link java.nio.file.Files#readAllBytes}.
   *
   * @param file the file to read from
   * @return a byte array containing all the bytes from file
   * @throws IllegalArgumentException if the file is bigger than the largest possible byte array

            return this;
        }

        /**
         * Adds the specified managed dependency.
         *
         * @param managedDependency The managed dependency to add, may be {@code null} in which case the call
         *                          will have no effect.
         * @return this request for chaining, never {@code null}
         */
        @Nonnull

    checkPositive("x", checkNotNull(x));
    int logFloor = x.bitLength() - 1;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x)); // fall through
      case DOWN:
      case FLOOR:
        return logFloor;

      case UP:
      case CEILING:
        return isPowerOfTwo(x) ? logFloor : logFloor + 1;

      case HALF_DOWN:
      case HALF_UP:

### `response_model` oder Rückgabewert

Da unsere zwei Modelle in diesem Fall unterschiedlich sind, würde, wenn wir den Rückgabewert der Funktion als `UserOut` deklarieren, der Editor sich beschweren, dass wir einen ungültigen Typ zurückgeben, weil das unterschiedliche Klassen sind.

Darum müssen wir es in diesem Fall im `response_model`-Parameter deklarieren.

    server2.useHttps(handshakeCertificates.sslSocketFactory())
  }

  private fun executeSynchronously(request: Request): RecordedResponse {
    val call = client.newCall(request)
    return try {
      val response = call.execute()
      val bodyString = response.body.string()
      RecordedResponse(request, response, null, bodyString, null)
    } catch (e: IOException) {

        buffer.putInt(20); // Owner offset
        buffer.putInt(40); // Group offset
        buffer.putInt(0); // SACL offset (null)
        buffer.putInt(60); // DACL offset

        // Owner SID at offset 20
        buffer.position(20);
        buffer.put((byte) 0x01); // Revision
        buffer.put((byte) 0x01); // SubAuthorityCount

        // we cannot directly verify them here without reflection or extending SamrOpenAlias for testing.
        // However, the primary responsibility of MsrpcSamrOpenAlias's constructor is to call the super constructor
        // and set its own specific fields (ptype, flags).
        // The fact that the object is successfully created implies the super constructor was called.
    }