For example, it was clear that ideally it should be based on standard Python type hints.

Also, the best approach was to use already existing standards.

        });
        try {
            pathMappingService.store(entity);
            saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

        final RelatedContent relatedContent = getRelatedContent(body).map(entity -> {
            try {
                relatedContentService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

        // Check for null bytes
        if (NULL_BYTE.matcher(path).find()) {
            log.warn("Path contains null bytes: {}", sanitizeForLog(path));
            throw new SmbException("Path contains null bytes");
        }

        // Check for control characters
        if (strictMode && CONTROL_CHARS.matcher(path).find()) {
            log.warn("Path contains control characters: {}", sanitizeForLog(path));

    @Override
    public boolean isWarnEnabled() {
        return logger.isLoggable(Level.WARNING);
    }

    @Override
    public void warn(final String message) {
        logger.logp(Level.WARNING, sourceClass, null, message);
    }

    @Override
    public void warn(final String message, final Throwable t) {
        logger.logp(Level.WARNING, sourceClass, null, message, t);
    }

    @Override

    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream was reset: CANCEL")
    }
    // Close throws because buffered data wasn't flushed.
    assertFailsWith<IOException> {
      out.close()
    }
    assertThat(connection.openStreamCount()).isEqualTo(0)

    // Verify the peer received what was expected.
    val synStream = peer.takeFrame()

	if l.LogLevel >= Info {
		l.Logger.InfoContext(ctx, msg, slog.Any("data", data))
	}
}

func (l *slogLogger) Warn(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Warn {
		l.Logger.WarnContext(ctx, msg, slog.Any("data", data))
	}
}

func (l *slogLogger) Error(ctx context.Context, msg string, data ...interface{}) {
	if l.LogLevel >= Error {

                        if (!errors.isEmpty()) {
                            logger.warn("{}", errors.stream().collect(Collectors.joining(", ")));
                            if (auth.isDebugActive() && StringUtil.isNotBlank(auth.getLastErrorReason())) {
                                logger.warn("Authentication Failure: {} - Reason: {}", errors.stream().collect(Collectors.joining(", ")),

        // Perform the renewal
        boolean renewed = wrapper.renewCredentials("locationHint", null);

        // Verify that renew() was called and credentials were updated
        assertTrue(renewed, "renewCredentials should return true when renewable credentials are renewed");

        // Verify that the wrap method was called exactly once
        verify(dcerpcSecurityProvider, times(1)).wrap(mockNdrBuffer);
    }

    @Test
    void testUnwrapMethodIsCalled() throws DcerpcException {
        // Test that the unwrap method can be called without throwing an exception
        dcerpcSecurityProvider.unwrap(mockNdrBuffer);

        // Verify that the unwrap method was called exactly once with the mockNdrBuffer