void accept_propagatesSmbException() throws Exception {
        // Arrange: filter delegates to isDirectory which may throw SmbException
        SmbFileFilter filter = f -> f.isDirectory();
        SmbException boom = new SmbException("io error");
        when(smbFile.isDirectory()).thenThrow(boom);

        // Act + Assert
        SmbException thrown = assertThrows(SmbException.class, () -> filter.accept(smbFile));

        this.mojo = mojo;

        this.parameters = parameters;
    }

    private static String format(List<Parameter> parameters) {
        StringBuilder buffer = new StringBuilder(128);
        if (parameters != null) {
            for (Parameter parameter : parameters) {
                if (!buffer.isEmpty()) {
                    buffer.append(", ");
                }

  private static final Map<Class<?>, Class<?>> WRAPPER_TO_PRIMITIVE_TYPE;

  // Sad that we can't use a BiMap. :(

  static {
    Map<Class<?>, Class<?>> primToWrap = new LinkedHashMap<>(16);
    Map<Class<?>, Class<?>> wrapToPrim = new LinkedHashMap<>(16);

    add(primToWrap, wrapToPrim, boolean.class, Boolean.class);
    add(primToWrap, wrapToPrim, byte.class, Byte.class);

   * {@code new ImmutableMapEntry[...]}, so it seems silly to insist on that only here.
   */
  @SuppressWarnings("unchecked") // Safe as long as the javadocs are followed
  static <K, V> ImmutableMapEntry<K, V>[] createEntryArray(int size) {
    return (ImmutableMapEntry<K, V>[]) new ImmutableMapEntry<?, ?>[size];
  }

  ImmutableMapEntry(K key, V value) {

func (p *providerCfg) UserInfo(ctx context.Context, accessToken string, transport http.RoundTripper) (map[string]any, error) {
	if p.JWKS.URL == nil || p.JWKS.URL.String() == "" {
		return nil, errors.New("openid not configured")
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, p.DiscoveryDoc.UserInfoEndpoint, nil)
	if err != nil {
		return nil, err
	}

	// This ensures that Close will block until Read has completed.
	// This allows another goroutine to close the reader.
	pr.closedMu.Lock()
	defer pr.closedMu.Unlock()
	if pr.closed {
		return 0, errors.New("progressReader: read after Close")
	}
	return pr.processedReader.Read(p)
}

func (pr *progressReader) Close() error {
	pr.closedMu.Lock()
	defer pr.closedMu.Unlock()
	if pr.closed {
		return nil
	}

 * limitations under the License.
 */
package gradlebuild.docs.dsl.docbook

import spock.lang.Specification

class BasicJavadocLexerTest extends Specification {
    final BasicJavadocLexer lexer = new BasicJavadocLexer(new JavadocScanner(""))
    final visitor = Mock(JavadocLexer.TokenVisitor)

    def parsesHtmlElements() {
        when:
        lexer.pushText("<p> text </p>")
        lexer.visit(visitor)

        then:

    /**
     * Creates {@link ClRuntimeException}.
     *
     * @param messageCode message code
     */
    public ClRuntimeException(final String messageCode) {
        this(messageCode, new Object[0], null);
    }

    /**
     * Creates {@link ClRuntimeException}.
     *
     * @param messageCode message code
     * @param args arguments for messages
     */

 *
 * @author mbechler
 */
public class Smb2WriteResponse extends ServerMessageBlock2Response {

    private int count;
    private int remaining;

    /**
     * Creates a new SMB2 write response.
     *
     * @param config the CIFS configuration
     */
    public Smb2WriteResponse(final Configuration config) {
        super(config);
    }

    /**

    public static ZipEntry getNextEntry(final ZipInputStream zis) {
        assertArgumentNotNull("zis", zis);

        try {
            return zis.getNextEntry();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * A method that wraps the exception handling of {@link ZipInputStream#reset()}.
     *
     * @param zis