}
                }

                // Check if the method's parameters are annotated with the wrong Nullable
                for (JavaParameter parameter : method.getParameters()) {
                    if (!parameter.isAnnotatedWith(Nullable.class)) {
                        Set<JavaAnnotation<JavaParameter>> annotations = parameter.getAnnotations();

                return;
            }

            Object returnValue;
            try {
                returnValue = targetMethod.invoke(invocation.getDelegate(), invocation.getParameters());
            } catch (InvocationTargetException e) {
                throw e.getCause();
            }

            invocation.setResult(returnValue);
        }

        @Nullable

/**
 * Wrapper around either a {@link Method} or a {@link Constructor}. Convenience API is provided to
 * make common reflective operation easier to deal with, such as {@link #isPublic}, {@link
 * #getParameters} etc.
 *
 * <p>In addition to convenience methods, {@link TypeToken#method} and {@link TypeToken#constructor}
 * will resolve the type parameters of the method or constructor in the context of the owner type,

        try {
            CallableInfo callable = request.getInterceptedCallable();
            ImplementationInfo implementation = request.getImplementationInfo();
            List<ParameterSpec> parameters = callable.getParameters().stream()
                .map(parameter -> ParameterSpec.builder(typeName(parameter.getParameterType()), parameter.getName()).build())
                .collect(Collectors.toList());

            if (Constants.SAMBA.equals(fileAuth.getProtocolScheme())) {
                final SmbAuthentication smbAuth = new SmbAuthentication();
                final Map<String, String> map = ParameterUtil.parse(fileAuth.getParameters());
                final String domain = map.get("domain");
                smbAuth.setDomain(domain == null ? StringUtil.EMPTY : domain);
                smbAuth.setServer(fileAuth.getHostname());

        Property<Boolean> getEnableStricterValidation();

    }

    @Override
    public void execute() {
        List<Problem> taskValidationProblems = new ArrayList<>();

        Params params = getParameters();

        params.getClasses().getAsFileTree().visit(new ValidationProblemCollector(taskValidationProblems, params));
        storeResults(taskValidationProblems, params.getOutputFile());
    }

/**
 * Wrapper around either a {@link Method} or a {@link Constructor}. Convenience API is provided to
 * make common reflective operation easier to deal with, such as {@link #isPublic}, {@link
 * #getParameters} etc.
 *
 * <p>In addition to convenience methods, {@link TypeToken#method} and {@link TypeToken#constructor}
 * will resolve the type parameters of the method or constructor in the context of the owner type,

                    public ProbeService() {}

                    public void probe(String eventName, String taskPath) {
                        String probe = Static.probe(getParameters().getProjectName().get());
                        System.out.println(eventName + ": " + taskPath + ": " + probe);
                    }

                    @Override

            }
        }

        return null;
    }

    public static XmlNode convert(org.apache.maven.api.plugin.descriptor.MojoDescriptor mojoDescriptor) {
        List<XmlNode> children = mojoDescriptor.getParameters().stream()
                .filter(p -> p.getDefaultValue() != null || p.getExpression() != null)
                .map(p -> new XmlNodeImpl(
                        p.getName(),
                        p.getExpression(),

                value = item.getString();
            }
            haveValue = true;
        }
        if (request instanceof final MultipartRequestWrapper wrapper) {
            wrapper.setParameter(name, value);
        }
        final String[] oldArray = elementsText.get(name);
        final String[] newArray;
        if (oldArray != null) {
            newArray = new String[oldArray.length + 1];